cms_thermo_active/Thermo.Active.Database/Redis/redUtil.cs

using NLog;
using StackExchange.Redis;
using System;
using System.Collections.Generic;

namespace Thermo.Active.Database.Redis
{

    public class redUtil
    {
        /// <summary>
        /// wrapper di log
        /// </summary>
        public static Logger lg;
        private const string baseHash = "SOUR";


        public redUtil()
        {
            lg = LogManager.GetCurrentClassLogger();
        }
        /// <summary>
        /// Metodo accesso statico
        /// </summary>
        public static redUtil man = new redUtil();

        #region gestione valori in RedisCache


        /// <summary>
        /// Nome della variabile HASH da utilizzare (dato CodModulo / Server / DB impiegato da funzionalita' DbConfig) + keyName richiesto...
        /// </summary>
        public string redHash(string keyName)
        {
            string answ = keyName;
            try
            {
                answ = string.Format("{0}:{1}", baseHash, keyName);
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// Connessione lazy a redis...
        /// </summary>
        private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            return ConnectionMultiplexer.Connect("127.0.0.1,abortConnect=false,ssl=false");
        });
        /// <summary>
        /// Connessione lazy a redis...
        /// </summary>
        private static Lazy<ConnectionMultiplexer> lazyConnectionAdmin = new Lazy<ConnectionMultiplexer>(() =>
        {
            return ConnectionMultiplexer.Connect("127.0.0.1,abortConnect=false,ssl=false,allowAdmin=true");
        });
        /// <summary>
        /// Oggetto statico connessione redis
        /// </summary>
        public static ConnectionMultiplexer connRedis
        {
            get
            {
                return lazyConnection.Value;
            }
        }
        /// <summary>
        /// Oggetto statico connessione redis
        /// </summary>
        public static ConnectionMultiplexer connRedisAdmin
        {
            get
            {
                return lazyConnectionAdmin.Value;
            }
        }
        /// <summary>
        /// Restituisce info dei server connessi...
        /// </summary>
        /// <returns></returns>
        public IServer[] redServInfo()
        {
            IServer[] answ = new IServer[1];
            if (connRedisAdmin.IsConnected)
            {
                try
                {
                    answ = new IServer[connRedisAdmin.GetEndPoints().Length];
                    int i = 0;
                    foreach (var ep in connRedisAdmin.GetEndPoints())
                    {
                        var server = connRedisAdmin.GetServer(ep);
                        answ[i] = server;
                        i++;
                    }
                }
                catch (Exception exc)
                {
                    lg.Error("Eccezione in redServInfo: " + exc.ToString());
                }
            }
            else
            {
                lg.Error("Server REDIS Admin non disponibile");
            }
            return answ;
        }

        /// <summary>
        /// Restituisce una chiave salvata in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public string getRSV(string chiave)
        {
            string answ = "";
            if (connRedis.IsConnected)
            {
                try
                {
                    IDatabase cache = connRedis.GetDatabase();
                    answ = cache.StringGet(chiave);
                }
                catch (Exception exc)
                {
                    lg.Info(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
                }
            }
            else
            {
                lg.Error("Server REDIS non disponibile per getRSV");
            }
            return answ;
        }
        /// <summary>
        /// Salva una chiave in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        /// <returns></returns>
        public bool setRSV(string chiave, string valore)
        {
            bool answ = false;
            if (connRedis.IsConnected)
            {
                try
                {
                    IDatabase cache = connRedis.GetDatabase();
                    cache.StringSet(chiave, valore);
                    answ = true;
                }
                catch (Exception exc)
                {
                    lg.Info(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
                }
            }
            else
            {
                lg.Error("Server REDIS non disponibile (setRSV)");
            }
            return answ;
        }
        /// <summary>
        /// Salva una chiave in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <param name="valore"></param>
        /// <param name="TTL_sec">in secondi</param>
        /// <returns></returns>
        public bool setRSV(string chiave, string valore, int TTL_sec)
        {
            bool answ = false;
            if (connRedis.IsConnected)
            {
                try
                {
                    IDatabase cache = connRedis.GetDatabase();
                    TimeSpan expT = new TimeSpan(0, 0, TTL_sec);
                    // salvo con expyry...
                    cache.StringSet(chiave, valore, expT);
                    answ = true;
                }
                catch (Exception exc)
                {
                    lg.Info(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
                }
            }
            else
            {
                lg.Error("Server REDIS non disponibile (setRSV:TTL)");
            }
            return answ;
        }
        /// <summary>
        /// Incrementa un contatore in Redis
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public long setRCntI(string chiave)
        {
            long answ = 0;
            try
            {
                IDatabase cache = connRedis.GetDatabase();
                answ = cache.StringIncrement(chiave, 1);
            }
            catch (Exception exc)
            {
                lg.Info(string.Format("Errore in setRCI:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }
        /// <summary>
        /// Decrementa un contatore in Redis
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public long setRCntD(string chiave)
        {
            long answ = 0;
            try
            {
                IDatabase cache = connRedis.GetDatabase();
                answ = cache.StringDecrement(chiave, 1);
            }
            catch (Exception exc)
            {
                lg.Info(string.Format("Errore in setRCD:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }
        /// <summary>
        /// Restituisce una chiave COUNTER in RedisCache
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public int getRCnt(string chiave)
        {
            int answInt = 0;
            string answ = "";
            try
            {
                IDatabase cache = connRedis.GetDatabase();
                answ = cache.StringGet(chiave);
                answInt = Convert.ToInt32(answ);
            }
            catch (Exception exc)
            {
                lg.Info(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
            }
            return answInt;
        }
        /// <summary>
        /// Resetta (elimina) un contatore in Redis
        /// </summary>
        /// <param name="chiave"></param>
        /// <returns></returns>
        public bool resetRCnt(string chiave)
        {
            bool answ = false;
            try
            {
                IDatabase cache = connRedis.GetDatabase();
                answ = cache.KeyDelete(chiave);
            }
            catch (Exception exc)
            {
                lg.Info(string.Format("Errore in resetRCnt:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }
        /// <summary>
        /// Restituisce un set KVP (Key Value Pair) salvati in RedisCache
        /// </summary>
        /// <param name="chiavi"></param>
        /// <returns></returns>
        public RedisValue[] getRKeys(RedisKey[] chiavi)
        {
            RedisValue[] answ = null;
            try
            {
                IDatabase cache = connRedis.GetDatabase();
                answ = cache.StringGet(chiavi);
            }
            catch (Exception exc)
            {
                lg.Info(string.Format("Errore in getRKeys:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }
        /// <summary>
        /// Salva  un set KVP (Key Value Pair) in RedisCache
        /// </summary>
        /// <param name="valori">Set KVP chiave-valore da salvare</param>
        /// <returns></returns>
        public bool setRKeys(KeyValuePair<RedisKey, RedisValue>[] valori)
        {
            bool answ = false;
            try
            {
                IDatabase cache = connRedis.GetDatabase();
                cache.StringSet(valori);
                answ = true;
            }
            catch (Exception exc)
            {
                lg.Info(string.Format("Errore in setRKeys:{0}{1}", Environment.NewLine, exc));
            }
            return answ;
        }
        /// <summary>
        /// Verifica se ci siano valori nella hash indicata...
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redHashPresent(RedisKey key)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                answ = cache.HashGetAll(key).Length > 0;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Verifica se ci siano valori nella hash indicata (string)
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redHashPresentSz(string key)
        {
            bool answ = false;
            try
            {
                RedisKey chiave = key;
                answ = redHashPresent(chiave);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Recupera tutti i valori dalla hash
        /// </summary>
        /// <param name="hashKey"></param>
        /// <returns></returns>
        public KeyValuePair<string, string>[] redGetHash(string hashKey)
        {
            KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = cache.HashGetAll(chiave);
                answ = new KeyValuePair<string, string>[valori.Length];
                int i = 0;
                foreach (HashEntry item in valori)
                {
                    answ[i] = new KeyValuePair<string, string>(item.Name, item.Value);
                    i++;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Recupera tutti i valori dalla hash in formato Dictionary
        /// </summary>
        /// <param name="hashKey"></param>
        /// <returns></returns>
        public Dictionary<string, string> redGetHashDict(string hashKey)
        {
            Dictionary<string, string> answ = new Dictionary<string, string>();
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = cache.HashGetAll(chiave);
                foreach (HashEntry item in valori)
                {
                    answ.Add(item.Name, item.Value);
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Recupera UN SINGOLO VALORE dalla hash per un dato field
        /// </summary>
        /// <param name="hashKey"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public string redGetHashField(string hashKey, string hashField)
        {
            string answ = "";
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = hashKey;
                RedisValue campo = hashField;
                RedisValue valOut = cache.HashGet(chiave, campo);
                answ = valOut.ToString();
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Salvataggio di una hash di valori
        /// </summary> 
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <returns></returns>
        public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields)
        {
            bool answ = false;
            if (connRedis.IsConnected)
            {
                // cerco se ci sia valore in redis...
                IDatabase cache = connRedis.GetDatabase();
                try
                {
                    RedisKey chiave = hashKey;
                    HashEntry[] valori = new HashEntry[hashFields.Length];
                    int i = 0;
                    foreach (KeyValuePair<string, string> kvp in hashFields)
                    {
                        valori[i] = new HashEntry(kvp.Key, kvp.Value);
                        i++;
                    }
                    cache.HashSet(chiave, valori);
                    answ = true;
                }
                catch
                { }
            }
            else
            {
                lg.Error("Server REDIS non disponibile (redSaveHash)");
            }
            return answ;
        }
        /// <summary>
        /// Salvataggio di una hash di valori
        /// </summary> 
        /// <param name="hashKey">chiave</param>
        /// <param name="hashListKVP">valori come lista KVP</param>
        /// <returns></returns>
        public bool redSaveHashList(string hashKey, List<KeyValuePair<string, string>> hashListKVP)
        {
            bool answ = false;
            if (connRedis.IsConnected)
            {
                // cerco se ci sia valore in redis...
                IDatabase cache = connRedis.GetDatabase();
                try
                {
                    RedisKey chiave = hashKey;
                    HashEntry[] valori = new HashEntry[hashListKVP.Count];
                    int i = 0;
                    foreach (KeyValuePair<string, string> kvp in hashListKVP)
                    {
                        valori[i] = new HashEntry(kvp.Key, kvp.Value);
                        i++;
                    }
                    cache.HashSet(chiave, valori);
                    answ = true;
                }
                catch
                { }
            }
            else
            {
                lg.Error("Server REDIS non disponibile (redSaveHashList)");
            }
            return answ;
        }
        /// <summary>
        /// Salvataggio di una hash di valori in formato Dictionary
        /// </summary> 
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <returns></returns>
        public bool redSaveHashDict(string hashKey, Dictionary<string, string> hashFields)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = hashKey;
                HashEntry[] valori = new HashEntry[hashFields.Count];
                int i = 0;
                foreach (KeyValuePair<string, string> kvp in hashFields)
                {
                    valori[i] = new HashEntry(kvp.Key, kvp.Value);
                    i++;
                }
                cache.HashSet(chiave, valori);
                answ = true;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Salvataggio di una hash di valori
        /// </summary> 
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <param name="expireSeconds">scadenza preimpostata hash (secondi) | defaoult = -1 (non scade)</param>
        /// <returns></returns>
        public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields, double expireSeconds = -1)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = hashKey;
                answ = redSaveHash(hashKey, hashFields);
                if (expireSeconds > 0)
                {
                    cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
                }
                //answ = true;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Salvataggio di una hash di valori in formato Dictionary
        /// </summary> 
        /// <param name="hashKey">chiave</param>
        /// <param name="hashFields">valori</param>
        /// <param name="expireSeconds">scadenza preimpostata hash (secondi) | defaoult = -1 (non scade)</param>
        /// <returns></returns>
        public bool redSaveHashDict(string hashKey, Dictionary<string, string> hashFields, double expireSeconds = -1)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = hashKey;
                answ = redSaveHashDict(hashKey, hashFields);
                if (expireSeconds > 0)
                {
                    cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
                }
                //answ = true;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Elimina una key (hash, string)
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool redDelKey(string key)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            try
            {
                RedisKey chiave = key;
                cache.KeyDelete(chiave);
                answ = true;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Flush completo cache redis
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <returns></returns>
        public bool redFlushKey(string keyPattern)
        {
            bool answ = false;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            // se vuoto = ALL...
            keyPattern = keyPattern == "" ? "**" : keyPattern;
            try
            {
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    foreach (var key in server.Keys(pattern: keyPattern))
                    {
                        cache.KeyDelete(key);
                    }
                }
                answ = true;
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione: {0}", exc));
            }
            return answ;
        }
        /// <summary>
        /// Conta num oggetti cache redis che rispondono a pattern
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <returns></returns>
        public int redCountKey(string keyPattern)
        {
            int answ = 0;
            // cerco se ci sia valore in redis...
            IDatabase cache = connRedis.GetDatabase();
            // se vuoto = ALL...
            keyPattern = keyPattern == "" ? "**" : keyPattern;
            try
            {
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    foreach (var key in server.Keys(pattern: keyPattern))
                    {
                        answ++;
                    }
                }
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione: {0}", exc));
            }
            return answ;
        }

        /// <summary>
        /// Restituisce numero record in Redis DB
        /// </summary>
        public long numRecRedis
        {
            get
            {
                long answ = 0;
                try
                {
                    foreach (var ep in connRedis.GetEndPoints())
                    {
                        var server = connRedis.GetServer(ep);
                        answ += server.DatabaseSize();
                    }
                }
                catch
                { }
                return answ;
            }
        }
        /// <summary>
        /// Restituisce oggetti cache redis che rispondono a pattern
        /// </summary>
        /// <param name="keyPattern">** = tutti</param>
        /// <param name="orderBy">Tipo di ordinamento per kvp</param>
        /// <returns></returns>
        public List<KeyValuePair<string, int>> redGetCounterByKey(string keyPattern, kvpOrderBy orderBy)
        {
            int numAnsw = redCountKey(keyPattern);
            RedisKey[] chiavi = new RedisKey[numAnsw];
            List<KeyValuePair<string, int>> answ = new List<KeyValuePair<string, int>>();
            // se vuoto = ALL...
            keyPattern = keyPattern == "" ? "**" : keyPattern;

            // recupero in primis elenco chiavi
            try
            {
                int i = 0;
                foreach (var ep in connRedis.GetEndPoints())
                {
                    var server = connRedis.GetServer(ep);
                    foreach (var key in server.Keys(pattern: keyPattern))
                    {
                        chiavi[i] = key;
                        i++;
                    }
                }
            }
            catch (Exception exc)
            {
                lg.Error(string.Format("Eccezione: {0}", exc));
            }
            // ora recupero valori!
            var valori = getRKeys(chiavi);
            int currVal = 0;
            // popolo rispsota
            try
            {
                for (int i = 0; i < numAnsw; i++)
                {
                    Int32.TryParse(valori[i], out currVal);
                    answ.Add(new KeyValuePair<string, int>(chiavi[i], currVal));
                }
            }
            catch
            { }
            // se richiesto riordino...
            switch (orderBy)
            {
                case kvpOrderBy.KeyAsc:
                    answ.Sort(CompareKey);
                    break;
                case kvpOrderBy.KeyDesc:
                    answ.Sort(CompareKeyDesc);
                    break;
                case kvpOrderBy.ValAsc:
                    answ.Sort(CompareVal);
                    break;
                case kvpOrderBy.ValDesc:
                    answ.Sort(CompareValDesc);
                    break;
                default:
                    break;
            }
            return answ;
        }
        /// <summary>
        /// Effettua comaprazione x CHIAVE in KVP ASC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        private int CompareKey(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return x.Key.CompareTo(y.Key);
        }
        /// <summary>
        /// Effettua comaprazione x VALORE in KVP ASC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int CompareVal(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return x.Value.CompareTo(y.Value);
        }
        /// <summary>
        /// Effettua comaprazione x CHIAVE in KVP DESC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        private int CompareKeyDesc(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return y.Key.CompareTo(x.Key);
        }
        /// <summary>
        /// Effettua comaprazione x VALORE in KVP DESC
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int CompareValDesc(KeyValuePair<string, int> x, KeyValuePair<string, int> y)
        {
            return y.Value.CompareTo(x.Value);
        }

        /// <summary>
        /// Tipologia di ordinamento x liste KVP
        /// </summary>
        public enum kvpOrderBy
        {
            /// <summary>
            /// Ordinamento ASCending per KEY
            /// </summary>
            KeyAsc,
            /// <summary>
            /// Ordinamento DESCending per KEY
            /// </summary>
            KeyDesc,
            /// <summary>
            /// Ordinamento ASCending per VAL
            /// </summary>
            ValAsc,
            /// <summary>
            /// Ordinamento DESCending per VAL
            /// </summary>
            ValDesc
        }



        #endregion
    }
}