limanapp/LiMan.DbSync/Services/BaseServ.cs

using Core;
using Microsoft.Extensions.Configuration;
using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace LiMan.DbSync.Services
{
    /// <summary>
    /// Classe di partenza x costruzione servizi di accesso dati + cache
    /// </summary>
    public class BaseServ
    {
        #region Protected Fields

        protected static Logger Log = LogManager.GetCurrentClassLogger();
        protected IConfiguration _configuration = null!;

        /// <summary>
        /// Durata cache lunga IN SECONDI
        /// </summary>
        protected int cacheTtlLong = 60 * 5;

        /// <summary>
        /// Durata cache breve IN SECONDI
        /// </summary>
        protected int cacheTtlShort = 60 * 1;

        /// <summary>
        /// Oggetto per connessione a REDIS
        /// </summary>
        protected IConnectionMultiplexer redisConn = null!;

        /// <summary>
        /// Oggetto DB redis da impiegare x chiamate R/W
        /// </summary>
        protected IDatabase redisDb = null!;

        protected Random rnd = new Random();

        #endregion Protected Fields

        #region Protected Properties

        /// <summary>
        /// Durata cache breve (1 min circa + perturbazione percentuale +/-10%)
        /// </summary>
        protected TimeSpan FastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        protected TimeSpan LongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache MOLTO breve (10 sec circa + perturbazione percentuale +/-10%)
        /// </summary>
        protected TimeSpan UltraFastCache
        {
            get => TimeSpan.FromSeconds(cacheTtlShort / 6 * rnd.Next(900, 1100) / 1000);
        }

        /// <summary>
        /// Durata cache MOLTO lunga (+ perturbazione percentuale +/-10%)
        /// </summary>
        protected TimeSpan UltraLongCache
        {
            get => TimeSpan.FromSeconds(cacheTtlLong * 10 * rnd.Next(900, 1100) / 1000);
        }

        #endregion Protected Properties

        #region Public Methods

        /// <summary>
        /// Refresh globale cache redis
        /// </summary>
        /// <returns></returns>
        public async Task<bool> FlushRedisCache()
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            await Task.Delay(1);
            RedisValue pattern = new RedisValue($"{Const.rKeyConfig}:*");
            bool answ = await ExecFlushRedisPattern(pattern);
            stopWatch.Stop();
            Log.Debug($"FlushRedisCache in {stopWatch.Elapsed.TotalMilliseconds} ms");
            return answ;
        }

        #endregion Public Methods

        #region Protected Methods

        /// <summary>
        /// Esegue flush memoria redis dato pat2Flush
        /// </summary>
        /// <param name="pat2Flush"></param>
        /// <returns></returns>
        protected async Task<bool> ExecFlushRedisPattern(RedisValue pat2Flush)
        {
            bool answ = false;
            var masterEndpoint = redisConn.GetEndPoints()
                                          .Where(ep => redisConn.GetServer(ep).IsConnected && !redisConn.GetServer(ep).IsReplica)
                                          .FirstOrDefault();

            // sepattern è "*" elimino intero DB...
            if (masterEndpoint != null && (pat2Flush.Equals(new RedisValue("*")) || pat2Flush == RedisValue.Null))
            {
                redisConn.GetServer(masterEndpoint).FlushDatabase(database: redisDb.Database);
            }
            else
            {
                var server = redisConn.GetServer(masterEndpoint);
                var keys = server.Keys(database: redisDb.Database, pattern: pat2Flush, pageSize: 1000);

                var deleteTasks = new List<Task>();
                foreach (var key in keys)
                {
                    deleteTasks.Add(redisDb.KeyDeleteAsync(key));
                    if (deleteTasks.Count >= 1000)
                    {
                        await Task.WhenAll(deleteTasks);
                        deleteTasks.Clear();
                    }
                }
                if (deleteTasks.Count > 0)
                {
                    await Task.WhenAll(deleteTasks);
                }
            }
            answ = true;
#if false
            var listEndpoints = redisConn.GetEndPoints();
            foreach (var endPoint in listEndpoints)
            {
                //var server = redisConnAdmin.GetServer(listEndpoints[0]);
                var server = redisConn.GetServer(endPoint);
                if (server != null)
                {
                    var keyList = server.Keys(redisDb.Database, pattern);
                    foreach (var item in keyList)
                    {
                        await redisDb.KeyDeleteAsync(item);
                    }
                    answ = true;
                }
            } 
#endif

            return answ;
        }

        #endregion Protected Methods
    }
}