FCC/Applications/FdcServer/FdcServerHost/FdcResourceArbitrator.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Edge.Core.Database;
using Edge.Core.Database.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace Applications.FDC
{
    public class FdcResourceArbitrator : IFdcResourceArbitrator
    {
        public static ILogger fdcLogger { get; set; }// = ServiceBuilder.Provider.GetRequiredService<ILoggerFactory>().CreateLogger("FdcServer");// NLog.LogManager.LoadConfiguration("nlog.config").GetLogger("FdcServer");
        private static FdcResourceArbitrator instance = new FdcResourceArbitrator();

        private object syncObject = new object();

        public static FdcResourceArbitrator Default => instance;

        //private SqliteDbContext dbContext;
        private FdcResourceArbitrator()
        {
        }

        private int __TryReserveFuelPointAsyncGuard = 0;
        public async Task<bool> TryReserveFuelPointAsync(int posId, int fuelPointId)
        {
            if (0 != Interlocked.CompareExchange(ref this.__TryReserveFuelPointAsyncGuard, 1, 0))
                return false;
            try
            {
                var dbContext = new SqliteDbContext();
                var existed = dbContext.FuelPointReservationModels.Where(f => f.FuelPointId == fuelPointId);
                if (!existed.Any())
                {
                    dbContext.FuelPointReservationModels.Add(new FuelPointReservation()
                    {
                        FuelPointId = fuelPointId,
                        ReservingTime = DateTime.Now,
                        ReservedByFdcClientId = posId
                    });
                    await dbContext.SaveChangesAsync();
                    fdcLogger.LogDebug("    created reservation");
                    return true;
                }

                // add a protection for deadlock by someone, if locked by lasted over 5m, auto unlocked it.
                int maxHoldTime = 5;
                if (existed.Any())
                {
                    var lockDue = DateTime.Now.Subtract(existed.First().ReservingTime);
                    if (lockDue >= new TimeSpan(0, maxHoldTime, 0))
                    {
                        fdcLogger.LogInformation("    FuelPoint with id: " + fuelPointId + " have been hold by "
                            + existed.First().ReservedByFdcClientId
                            + " for " + lockDue.TotalMinutes + " minutes (since: "
                            + existed.First().ReservingTime.ToString("yyyy-MM-dd HH:mm:ss") + "), will auto unlock it for avoid long lock");
                        dbContext.FuelPointReservationModels.Remove(existed.First());
                        await dbContext.SaveChangesAsync();
                        existed = dbContext.FuelPointReservationModels.Where(f => f.FuelPointId == fuelPointId);
                    }
                }

                if (!existed.Any())
                {
                    dbContext.FuelPointReservationModels.Add(new FuelPointReservation()
                    {
                        FuelPointId = fuelPointId,
                        ReservingTime = DateTime.Now,
                        ReservedByFdcClientId = posId
                    });
                    await dbContext.SaveChangesAsync();
                    fdcLogger.LogDebug("    Created a FuelPoint Reservation for FdcClientId: " + posId);
                    return true;
                }
                else
                {
                    if (existed.First().ReservedByFdcClientId != posId)
                    {
                        fdcLogger.LogDebug("    ReserveFuelPoint failed due to Fp already locked by FdcClientId: " + existed.First().ReservedByFdcClientId);
                        return false;
                    }
                    else
                    {
                        // refresh the time
                        existed.First().ReservingTime = DateTime.Now;
                        await dbContext.SaveChangesAsync();
                        fdcLogger.LogDebug("    Updated FuelPoint ReservingTime since previous already reserved by caller FdcClientId: " + posId);
                        return true;
                    }
                }
            }
            catch (Exception exxx)
            {
                fdcLogger.LogError("TryReserveFuelPoint exceptioned: " + exxx.ToString());
                return false;
            }
            finally
            {
                this.__TryReserveFuelPointAsyncGuard = 0;
            }
        }

        private int __TryUnreserveFuelPointAsyncGuard = 0;
        public async Task<bool> TryUnreserveFuelPointAsync(int posId, int fuelPointId)
        {
            if (0 != Interlocked.CompareExchange(ref this.__TryUnreserveFuelPointAsyncGuard, 1, 0))
                return false;
            try
            {
                var dbContext = new SqliteDbContext();
                var reservedBySelf = dbContext.FuelPointReservationModels.Where(f => f.FuelPointId == fuelPointId
                    && f.ReservedByFdcClientId == posId);
                if (!reservedBySelf.Any())
                {
                    fdcLogger.LogError("    failed on unreserve target pump with pump id:" + fuelPointId
                        + " since it didn't get reserved or others already reserved it");
                    return false;
                }
                else
                {
                    dbContext.FuelPointReservationModels.Remove(reservedBySelf.First());
                    await dbContext.SaveChangesAsync();
                    return true;
                }
            }
            catch (Exception exxx)
            {
                fdcLogger.LogError("TryUnreserveFuelPoint exceptioned: " + exxx.ToString());
                return false;
            }
            finally
            {
                this.__TryUnreserveFuelPointAsyncGuard = 0;
            }
        }

        private int __TryLockFuelSaleTrxAsyncGuard = 0;
        public async Task<FuelSaleTransaction> TryLockFuelSaleTrxAsync(int posId, int fuelPointId, int transactionNo, int trxDbUniqueId)
        {
            if (0 != Interlocked.CompareExchange(ref this.__TryLockFuelSaleTrxAsyncGuard, 1, 0))
                return null;
            try
            {
                var dbContext = new SqliteDbContext();
                var targetTrx = dbContext.PumpTransactionModels.Where(f =>
                    f.ReleaseToken == trxDbUniqueId
                    && f.PumpId == fuelPointId
                    && f.TransactionSeqNumberFromPhysicalPump == transactionNo.ToString()
                    && f.State == FuelSaleTransactionState.Payable).OrderByDescending(t => t.SaleStartTime).FirstOrDefault();
                byte maxRetryTimes = 3;
                byte retriedTimes = 0;
            retry:
                if (targetTrx != null)
                {
                    if (string.IsNullOrEmpty(targetTrx.LockedByFdcClientId))
                    {
                        targetTrx.LockedTime = DateTime.Now;
                        targetTrx.LockedByFdcClientId = posId.ToString();
                        targetTrx.State = FuelSaleTransactionState.Locked;
                        try
                        {
                            await dbContext.SaveChangesAsync();
                        }
                        catch (DbUpdateConcurrencyException ex)
                        {
                            fdcLogger.LogInformation("    lock FuelSaleTrx failed due to DbUpdateConcurrencyException, targetTrx in app memory is: "
                                + targetTrx.ToString());
                            try
                            {
                                // Update the values of the entity that failed to save from the store 
                                ex.Entries.Single().Reload();
                                fdcLogger.LogInformation("    while the actual in db is: "
                                    + targetTrx.ToString()
                                    + System.Environment.NewLine + "will retry saving...");
                                retriedTimes++;
                                if (retriedTimes > maxRetryTimes)
                                { fdcLogger.LogInformation("    DbUpdateConcurrency retried time reached its max, will quit."); return null; }
                                goto retry;
                            }
                            catch (Exception exxx)
                            {
                                fdcLogger.LogInformation("    exceptioned again for reload targetTrx from db: " + exxx);
                                return null;
                            }
                        }

                        return targetTrx;
                    }
                    else if (targetTrx.LockedByFdcClientId == posId.ToString())
                    {
                        fdcLogger.LogDebug("    lock FuelSaleTrx succeed since POS: " + posId + " already own it");
                        return targetTrx;
                    }
                    else
                    {
                        fdcLogger.LogInformation("    lock FuelSaleTrx failed due to it already locked by other POS: "
                            + targetTrx.LockedByFdcClientId + " at "
                            + (targetTrx.LockedTime?.ToString("yyyy-MM-dd HH:mm:ss") ?? ""));
                        return null;
                    }
                }
                else
                {
                    fdcLogger.LogInformation("    lock FuelSaleTrx failed since it not existed or state is not Payable");
                    return null;
                }
            }
            catch (Exception exxx)
            {
                fdcLogger.LogError("TryLockFuelSaleTrx exceptioned: " + exxx.ToString());
                return null;
            }
            finally { this.__TryLockFuelSaleTrxAsyncGuard = 0; }
        }

        private int __TryUnlockFuelSaleTrxAsyncGuard = 0;
        /// <summary>
        /// Try set the SaleTrx state to Payable.
        /// </summary>
        /// <param name="posId"></param>
        /// <param name="fuelPointId"></param>
        /// <param name="transactionNo"></param>
        /// <param name="trxDbUniqueId"></param>
        /// <returns></returns>
        public async Task<FuelSaleTransaction> TryUnlockFuelSaleTrxAsync(int posId, int fuelPointId, int transactionNo, int trxDbUniqueId)
        {
            if (0 != Interlocked.CompareExchange(ref this.__TryUnlockFuelSaleTrxAsyncGuard, 1, 0))
                return null;
            try
            {
                var dbContext = new SqliteDbContext();
                var targetTrx = dbContext.PumpTransactionModels.Where(f =>
                    f.ReleaseToken == trxDbUniqueId
                    && f.PumpId == fuelPointId
                    && f.TransactionSeqNumberFromPhysicalPump == transactionNo.ToString()
                    && f.State == FuelSaleTransactionState.Locked
                    && f.LockedByFdcClientId == posId.ToString()).FirstOrDefault();
                if (targetTrx != null)
                {
                    fdcLogger.LogDebug("    unlock FuelSaleTrx succeed");
                    targetTrx.LockedByFdcClientId = "";
                    targetTrx.LockedTime = DateTime.MinValue;
                    targetTrx.State = FuelSaleTransactionState.Payable;
                    await dbContext.SaveChangesAsync();
                    return targetTrx;
                }
                else
                {
                    fdcLogger.LogInformation("    unlock FuelSaleTrx failed");
                    return null;
                }
            }
            catch (Exception exxx)
            {
                fdcLogger.LogError("TryUnlockFuelSaleTrx exceptioned: " + exxx.ToString());
                return null;
            }
            finally { this.__TryUnlockFuelSaleTrxAsyncGuard = 0; }
        }

        //private int __TryLockNozzleAsyncGuard = 0;
        ///// <summary>
        ///// 
        ///// </summary>
        ///// <param name="posId"></param>
        ///// <param name="fuelPointId"></param>
        ///// <param name="logicalNozzleId"></param>
        ///// <returns></returns>
        //public async Task<bool> TryLockNozzleAsync(int posId, int fuelPointId, int logicalNozzleId)
        //{
        //    if (0 != Interlocked.CompareExchange(ref this.__TryLockNozzleAsyncGuard, 1, 0))
        //        return false;
        //    try
        //    {
        //        var dbContext = new SqliteDbContext();
        //        var existsLockingNozzleRecord = dbContext.NozzleLocks.Where(f =>
        //            f.FuelPointId == fuelPointId
        //            && f.LogicalNozzleId == logicalNozzleId).FirstOrDefault();
        //        if (existsLockingNozzleRecord != null)
        //        {
        //            if (existsLockingNozzleRecord.LockedByFdcClientId != null
        //                && existsLockingNozzleRecord.LockedByFdcClientId == posId)
        //            {
        //                existsLockingNozzleRecord.LockingTime = DateTime.Now;
        //                try
        //                {
        //                    await dbContext.SaveChangesAsync();
        //                    return true;
        //                }
        //                catch (Exception ex)
        //                {
        //                    fdcLogger.LogInformation("    exceptioned for updating locking time for lock nozzle from db: " + ex);
        //                    return false;
        //                }
        //            }
        //            else if (existsLockingNozzleRecord.LockedByFdcClientId != null
        //                && existsLockingNozzleRecord.LockedByFdcClientId != posId)
        //            {
        //                fdcLogger.LogInformation("    lock nozzle failed due to already locked by POS: " + existsLockingNozzleRecord.LockedByFdcClientId);
        //                return false;
        //            }
        //        }

        //        try
        //        {
        //            var newNozzleLocking = new NozzleLock()
        //            {
        //                LockingTime = DateTime.Now,
        //                LockedByFdcClientId = posId,
        //                FuelPointId = fuelPointId,
        //                LogicalNozzleId = logicalNozzleId
        //            };
        //            dbContext.NozzleLocks.Add(newNozzleLocking);
        //            await dbContext.SaveChangesAsync();
        //            return true;
        //        }
        //        catch (Exception ex)
        //        {

        //            fdcLogger.LogInformation("    exceptioned for create a lock nozzle from db: " + ex);
        //            return false;
        //        }
        //    }
        //    catch { return false; }
        //    finally { this.__TryLockNozzleAsyncGuard = 0; }
        //}

        //private int __TryUnlockNozzleAsyncGuard = 0;
        ///// <summary>
        ///// 
        ///// </summary>
        ///// <param name="posId"></param>
        ///// <param name="fuelPointId"></param>
        ///// <param name="logicalNozzleId"></param>
        ///// <returns></returns>
        //public async Task<NozzleLock> TryUnlockNozzleAsync(int posId, int fuelPointId, int logicalNozzleId)
        //{
        //    if (0 != Interlocked.CompareExchange(ref this.__TryUnlockNozzleAsyncGuard, 1, 0))
        //        return null;
        //    try
        //    {
        //        var dbContext = new SqliteDbContext();
        //        var targetTrx = dbContext.NozzleLocks.Where(f =>
        //            f.FuelPointId == fuelPointId
        //            && f.LogicalNozzleId == logicalNozzleId
        //            && f.LockedByFdcClientId == posId).FirstOrDefault();
        //        if (targetTrx != null)
        //        {
        //            fdcLogger.LogDebug("    unlock NozzleAsync succeed");
        //            targetTrx.LockedByFdcClientId = null;
        //            targetTrx.LockingTime = null;
        //            await dbContext.SaveChangesAsync();
        //            return targetTrx;
        //        }
        //        else
        //        {
        //            fdcLogger.LogInformation("    unlock NozzleAsync failed");
        //            return null;
        //        }
        //    }
        //    catch (Exception exxx)
        //    {
        //        fdcLogger.LogError("TryUnlockNozzleAsync exceptioned: " + exxx.ToString());
        //        return null;
        //    }
        //    finally { this.__TryUnlockNozzleAsyncGuard = 0; }
        //}
    }
}