Samuele Locatelli
1515 lines
50 KiB
C#
1515 lines
50 KiB
C#
using Microsoft.Extensions.Logging;
|
|
using Newtonsoft.Json;
|
|
using StackExchange.Redis;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace IOB_UT_NEXT
|
|
{
|
|
public class RedisIobCache
|
|
{
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// Hash REDIS x dati IOB
|
|
/// </summary>
|
|
public string redIobTrackKey = "";
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// init classe "implicita"
|
|
/// </summary>
|
|
/// <param name="codServer"></param>
|
|
/// <param name="codIob"></param>
|
|
public RedisIobCache()
|
|
{
|
|
initMemKeys();
|
|
}
|
|
|
|
/// <summary>
|
|
/// init classe gestione dati IOB su Redis
|
|
/// </summary>
|
|
/// <param name="codServer">IP/nome server</param>
|
|
/// <param name="codIob">Cod IOB</param>
|
|
/// <param name="tipoIob">Tipo di IOB</param>
|
|
/// <param name="minDeltaS">
|
|
/// Minima differenza in secondi x considerare variazione dati DataOra
|
|
/// </param>
|
|
public RedisIobCache(string codServer, string codIob, string tipoIob, int minDeltaS)
|
|
{
|
|
// init dati di base...
|
|
currCodIob = codIob;
|
|
currIobType = tipoIob;
|
|
initMemKeys();
|
|
// init oggetti gestiti
|
|
ServerMpStatus newSrvStatus = new ServerMpStatus()
|
|
{
|
|
IP = codServer,
|
|
online = false
|
|
};
|
|
servStatus = newSrvStatus;
|
|
// init oggetto IOB
|
|
IobWinStatus newIobStatus = new IobWinStatus()
|
|
{
|
|
CodIob = currCodIob,
|
|
IobType = currIobType,
|
|
online = false,
|
|
minDeltaSec = minDeltaS
|
|
};
|
|
iobStatus = newIobStatus;
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Enums
|
|
|
|
/// <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 Public Enums
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Oggetto DB REDIS corrente
|
|
/// </summary>
|
|
public IDatabase cache //currDB
|
|
{
|
|
get
|
|
{
|
|
IDatabase answ;
|
|
// se già valorizzato uso oggetto private...
|
|
if (_currDB != null)
|
|
{
|
|
answ = _currDB;
|
|
}
|
|
else
|
|
{
|
|
// init DB (sullo 0)
|
|
answ = connRedis.GetDatabase();
|
|
// gestione override...
|
|
if (baseUtils.CRI("redisDb") >= 0)
|
|
{
|
|
// in questo caso uso il DB configurato in app.config...
|
|
answ = connRedis.GetDatabase(baseUtils.CRI("redisDb"));
|
|
}
|
|
_currDB = answ;
|
|
}
|
|
// restituisco oggetto DB
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Oggetto statico connessione redis
|
|
/// </summary>
|
|
public ConnectionMultiplexer connRedis
|
|
{
|
|
get
|
|
{
|
|
return lazyConnection.Value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Oggetto statico connessione redis
|
|
/// </summary>
|
|
public ConnectionMultiplexer connRedisAdmin
|
|
{
|
|
get
|
|
{
|
|
return lazyConnectionAdmin.Value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Accesso all'oggetto stato IOB da esterno
|
|
/// </summary>
|
|
public IobWinStatus iobStatus
|
|
{
|
|
get
|
|
{
|
|
IobWinStatus answ = null;
|
|
// cerco in REDIS
|
|
string rawData = getRSV(redIobKey);
|
|
// se non ci fosse creo e salvo
|
|
if (string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = new IobWinStatus()
|
|
{
|
|
CodIob = currCodIob,
|
|
IobType = currIobType,
|
|
online = false
|
|
};
|
|
// salvo serializzando...
|
|
rawData = JsonConvert.SerializeObject(answ);
|
|
setRSV(redIobKey, rawData);
|
|
}
|
|
else
|
|
{
|
|
// deserializzo
|
|
answ = JsonConvert.DeserializeObject<IobWinStatus>(rawData);
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
string rawData = JsonConvert.SerializeObject(value);
|
|
saveAndSendMessage(redIobKey, redIobChannel, rawData);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// MEssage Dispatcher: oggetto comunicazione pub/sub via REDIS channels corrente
|
|
/// </summary>
|
|
public ISubscriber messageDisp
|
|
{
|
|
get
|
|
{
|
|
ISubscriber answ;
|
|
// se già valorizzato uso oggetto private...
|
|
if (_currSub != null)
|
|
{
|
|
answ = _currSub;
|
|
}
|
|
else
|
|
{
|
|
// init DB (sullo 0)
|
|
answ = connRedis.GetSubscriber();
|
|
_currSub = answ;
|
|
}
|
|
// restituisco oggetto DB
|
|
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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"numRecRedis {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Accesso all'oggetto stato server da esterno
|
|
/// </summary>
|
|
public ServerMpStatus servStatus
|
|
{
|
|
get
|
|
{
|
|
ServerMpStatus answ = null;
|
|
// cerco in REDIS
|
|
string rawData = getRSV(redServKey);
|
|
// se non ci fosse creo e salvo
|
|
if (string.IsNullOrEmpty(rawData))
|
|
{
|
|
answ = new ServerMpStatus()
|
|
{
|
|
online = false
|
|
};
|
|
// salvo serializzando...
|
|
rawData = JsonConvert.SerializeObject(answ);
|
|
setRSV(redServKey, rawData);
|
|
}
|
|
else
|
|
{
|
|
// deserializzo
|
|
answ = JsonConvert.DeserializeObject<ServerMpStatus>(rawData);
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
string rawData = JsonConvert.SerializeObject(value);
|
|
setRSV(redServKey, rawData);
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Pulisce gli eventi più vecchi di un certo numero di minuti sia dal Sorted Set che dalla Hash Table.
|
|
/// </summary>
|
|
/// <param name="rkeyTS">Chiave ZSet eventi tracciati per recupero recenti</param>
|
|
/// <param name="rkeyHash">Chiave hashset valore eventi</param>
|
|
/// <param name="minutesOldThreshold">Il numero di minuti oltre il quale gli eventi sono considerati "scaduti".</param>
|
|
public async Task CleanExpiredEventsAsync(string rkeyTS, string rkeyHash, int minutesOldThreshold)
|
|
{
|
|
long cutoffTimeMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - (long)TimeSpan.FromMinutes(minutesOldThreshold).TotalMilliseconds;
|
|
|
|
// PRIMA: Recupera gli ID degli eventi che saranno rimossi dal Sorted Set.
|
|
// Facciamo questo per poter poi rimuovere i loro dettagli dalla Hash Table.
|
|
// Utilizziamo ZRangeByScoreAsync con un intervallo da -infinito fino al cutoffTimeMillis.
|
|
RedisValue[] eventIdsToClean = await cache.SortedSetRangeByScoreAsync(
|
|
rkeyTS,
|
|
//start: double.NegativeInfinity, // Per ottenere tutti gli elementi dal più vecchio, uso default
|
|
stop: cutoffTimeMillis,
|
|
exclude: Exclude.None,
|
|
order: Order.Ascending // Non strettamente necessario, ma può aiutare per debug
|
|
);
|
|
|
|
if (eventIdsToClean == null || eventIdsToClean.Length == 0)
|
|
{
|
|
Logging.Instance.Debug("Nessun evento scaduto da pulire.");
|
|
return;
|
|
}
|
|
|
|
// Operazione 1 nel batch: Rimuovi gli eventi scaduti dal Sorted Set.
|
|
// ZRemRangeByScoreAsync rimuove tutti i membri con score <= al max specificato.
|
|
await cache.SortedSetRemoveRangeByScoreAsync(rkeyTS, double.NegativeInfinity, cutoffTimeMillis);
|
|
|
|
// Operazione 2 nel batch: Rimuovi i dettagli corrispondenti dalla Hash Table.
|
|
// Dobbiamo convertire i RedisValue[] in string[] per HDelAsync che accetta params RedisValue[]
|
|
RedisValue[] eventIdsAsRedisValues = eventIdsToClean.Select(id => (RedisValue)id.ToString()).ToArray();
|
|
await cache.HashDeleteAsync(rkeyHash, eventIdsAsRedisValues);
|
|
Logging.Instance.Debug($"Pulizia completata. Rimossi {eventIdsToClean.Length} eventi più vecchi di {minutesOldThreshold} minuti.");
|
|
}
|
|
|
|
/// <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 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>
|
|
/// Deserializzazione di un valore string in oggetto generico
|
|
/// </summary>
|
|
/// <param name="serVal"></param>
|
|
/// <returns></returns>
|
|
public object deserializeVal(string serVal)
|
|
{
|
|
object answ = "";
|
|
try
|
|
{
|
|
answ = JsonConvert.DeserializeObject(serVal);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"deserializeVal {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public int getKReqCount(string keyReq)
|
|
{
|
|
string keyReqHash = redHash($"IOB:{currCodIob}:KRCOUNT:{keyReq}");
|
|
int answ = 0;
|
|
string rawData = getRSV(keyReqHash);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
int.TryParse(rawData, out answ);
|
|
}
|
|
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
|
|
{
|
|
answ = cache.StringGet(chiave);
|
|
answInt = Convert.ToInt32(answ);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"getRCnt {exc}");
|
|
}
|
|
return answInt;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera gli eventi degli ultimi minuti specificati e ne somma la quantità di dati.
|
|
/// </summary>
|
|
/// <param name="rkeyTS">Chiave ZSet eventi tracciati per recupero recenti</param>
|
|
/// <param name="rkeyHash">Chiave hashset valore eventi</param>
|
|
/// <param name="minutesBack">Il numero di minuti da cui recuperare gli eventi.</param>
|
|
/// <returns>Una tupla contenente la quantità totale di dati scambiati e un elenco degli eventi trovati.</returns>
|
|
public async Task<(long TotalDataExchanged, List<(string EventId, long Data)> EventList)> GetRecentEventsAndSumAsync(string rkeyTS, string rkeyHash, int minutesBack)
|
|
{
|
|
long currentTimeMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
long fiveMinutesAgoMillis = currentTimeMillis - (long)TimeSpan.FromMinutes(minutesBack).TotalMilliseconds;
|
|
|
|
// Recupera gli ID degli eventi dal Sorted Set nell'intervallo di tempo
|
|
// `SortedSetRangeByScoreAsync` restituisce i membri il cui score rientra nell'intervallo.
|
|
// I membri sono RedisValue, quindi potrebbero essere necessari .ToString() o .ToByteArray()
|
|
RedisValue[] eventIds = await cache.SortedSetRangeByScoreAsync(
|
|
rkeyTS,
|
|
start: fiveMinutesAgoMillis,
|
|
stop: currentTimeMillis,
|
|
exclude: Exclude.None, // Includi entrambi gli estremi
|
|
order: Order.Ascending // Ordina per timestamp crescente
|
|
);
|
|
|
|
if (eventIds == null || eventIds.Length == 0)
|
|
{
|
|
return (0, new List<(string, long)>());
|
|
}
|
|
// Prepara l'array di RedisValue per la query HMGET
|
|
RedisValue[] eventIdsAsRedisValues = eventIds.ToList().Select(id => (RedisValue)id.ToString()).ToArray();
|
|
// Recupera le quantità di dati dalla Hash Table per gli ID trovati
|
|
// HMGET restituisce un array di RedisValue corrispondente ai field richiesti.
|
|
RedisValue[] dataQuantities = await cache.HashGetAsync(rkeyHash, eventIdsAsRedisValues);
|
|
long totalDataExchanged = 0;
|
|
var eventList = new List<(string EventId, long Data)>();
|
|
for (int i = 0; i < eventIds.Length; i++)
|
|
{
|
|
string eventId = eventIds[i].ToString();
|
|
RedisValue quantityRedisValue = dataQuantities[i];
|
|
if (quantityRedisValue.HasValue && long.TryParse(quantityRedisValue.ToString(), out long quantity))
|
|
{
|
|
totalDataExchanged += quantity;
|
|
eventList.Add((eventId, quantity));
|
|
}
|
|
else
|
|
{
|
|
Logging.Instance.Debug("Avviso: Dati mancanti o non validi per l'evento ID: {eventId}");
|
|
}
|
|
}
|
|
|
|
Logging.Instance.Debug("Totale dati scambiati negli ultimi {minutesBack} minuti: {totalDataExchanged}");
|
|
Logging.Instance.Debug("Elenco eventi trovati: {eventList.Count}");
|
|
return (totalDataExchanged, eventList);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce un pò di info sul server redis connesso
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string getRedisInfoData()
|
|
{
|
|
string answ = "";
|
|
StringBuilder sb = new StringBuilder();
|
|
try
|
|
{
|
|
sb.AppendLine($"Configuration: {connRedis.Configuration}");
|
|
sb.AppendLine($"Connected: {connRedis.IsConnected}");
|
|
sb.AppendLine($"ClientName: {connRedis.ClientName}");
|
|
sb.AppendLine($"Total Ops: {connRedis.OperationCount}");
|
|
sb.AppendLine($"Status: {connRedis.GetStatus()}");
|
|
answ = sb.ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"getRedisInfoData {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
|
|
{
|
|
answ = cache.StringGet(chiavi);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"getRKeys {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce una chiave salvata in RedisCache
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public string getRSV(string chiave)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = cache.StringGet(chiave);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Info($"getRSV {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... se vuoto = ALL...
|
|
keyPattern = string.IsNullOrEmpty(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)
|
|
{
|
|
Logging.Instance.Error($"redCountKey {exc}");
|
|
}
|
|
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...
|
|
try
|
|
{
|
|
RedisKey chiave = key;
|
|
cache.KeyDelete(chiave);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redDelKey {exc}");
|
|
}
|
|
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... se vuoto = ALL...
|
|
keyPattern = string.IsNullOrEmpty(keyPattern) ? "**" : keyPattern;
|
|
try
|
|
{
|
|
foreach (var ep in connRedis.GetEndPoints())
|
|
{
|
|
var server = connRedis.GetServer(ep);
|
|
var keys = server.Keys(database: baseUtils.CRI("redisDb"), pattern: $"{keyPattern}*");
|
|
foreach (var key in keys)
|
|
{
|
|
cache.KeyDelete(key);
|
|
}
|
|
}
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redFlushKey {exc}");
|
|
}
|
|
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 = string.IsNullOrEmpty(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)
|
|
{
|
|
Logging.Instance.Error($"redGetCounterByKey 01 {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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redGetCounterByKey 02 {exc}");
|
|
}
|
|
// 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>
|
|
/// 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...
|
|
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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redGetHash {exc}");
|
|
}
|
|
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...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
HashEntry[] valori = cache.HashGetAll(chiave);
|
|
foreach (HashEntry item in valori)
|
|
{
|
|
answ.Add(item.Name, item.Value);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redGetHashDict {exc}");
|
|
}
|
|
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...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
RedisValue campo = hashField;
|
|
RedisValue valOut = cache.HashGet(chiave, campo);
|
|
answ = valOut.ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redGetHashField {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nome della variabile HASH da utilizzare (dato CodModulo / Server / DB impiegato da
|
|
/// funzionalita' DbConfig) + keyName richiesto...
|
|
/// </summary>
|
|
public string redHash(string keyName)
|
|
{
|
|
keyName = keyName.Replace("\\", "_");
|
|
string answ = keyName;
|
|
try
|
|
{
|
|
answ = string.Format($"{baseUtils.CRS("appName")}:{keyName}");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redHash {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...
|
|
try
|
|
{
|
|
answ = cache.HashGetAll(key).Length > 0;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redHashPresent {exc}");
|
|
}
|
|
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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redHashPresentSz {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Incremento conteggio di un valore dentro una hash
|
|
/// </summary>
|
|
/// <param name="hashKey">chiave</param>
|
|
/// <param name="hashField">valore con conteggio da tracciare</param>
|
|
/// <param name="hashExpire">scadenza preimpostata hash datetime, se null NON scade</param>
|
|
/// <returns></returns>
|
|
public bool redIncrHashCount(string hashKey, string hashField, DateTime? hashExpire)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
cache.HashIncrement(chiave, hashField, 1);
|
|
if (hashExpire != null)
|
|
{
|
|
cache.KeyExpire(chiave, hashExpire);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redIncrHashCount {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se ci siano valori nella KEY indicata...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public bool redKeyPresent(RedisKey key)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
try
|
|
{
|
|
answ = cache.KeyExists(key);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redKeyPresent {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se ci siano valori nella KEY indicata (string)
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public bool redKeyPresentSz(string key)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
RedisKey chiave = key;
|
|
answ = redKeyPresent(chiave);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redKeyPresentSz {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conteggio elementi in QUEUE (FIFO)
|
|
/// </summary>
|
|
/// <param name="queueName"></param>
|
|
/// <param name="value"></param>
|
|
public long redQueueCount(RedisKey queueName)
|
|
{
|
|
return cache.ListLength(queueName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero valore in QUEUE (FIFO)
|
|
/// </summary>
|
|
/// <param name="queueName"></param>
|
|
/// <param name="value"></param>
|
|
public RedisValue redQueuePop(RedisKey queueName)
|
|
{
|
|
return cache.ListLeftPop(queueName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scrittura valore in QUEUE (FIFO)
|
|
/// </summary>
|
|
/// <param name="queueName"></param>
|
|
/// <param name="value"></param>
|
|
public void redQueuePush(RedisKey queueName, RedisValue value)
|
|
{
|
|
cache.ListRightPush(queueName, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// RIMUOVE un singolo valore (riga) dalla hash
|
|
/// </summary>
|
|
/// <param name="hashKey"></param>
|
|
/// <param name="hashField"></param>
|
|
/// <returns></returns>
|
|
public string redRemoveHashField(string hashKey, string hashField)
|
|
{
|
|
string answ = "";
|
|
// cerco se ci sia valore in redis...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
RedisValue campo = hashField;
|
|
RedisValue valOut = cache.HashDelete(chiave, campo);
|
|
answ = valOut.ToString();
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redRemoveHashField{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio di una hash di valori
|
|
/// </summary>
|
|
/// <param name="hashKey">chiave</param>
|
|
/// <param name="hashFields">valori</param>
|
|
/// <param name="hashExpire">scadenza preimpostata hash datetime, se null NON scade</param>
|
|
/// <returns></returns>
|
|
public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields, DateTime? hashExpire)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
answ = redSaveHash(hashKey, hashFields);
|
|
if (hashExpire != null)
|
|
{
|
|
cache.KeyExpire(chiave, hashExpire);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redSaveHash {exc}");
|
|
}
|
|
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;
|
|
// cerco se ci sia valore in redis...
|
|
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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redSaveHash {exc}");
|
|
}
|
|
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) | default = -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...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
answ = redSaveHash(hashKey, hashFields);
|
|
if (expireSeconds > 0)
|
|
{
|
|
cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redSaveHash {exc}");
|
|
}
|
|
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...
|
|
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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redSaveHashDict {exc}");
|
|
}
|
|
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) | default = -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...
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
answ = redSaveHashDict(hashKey, hashFields);
|
|
if (expireSeconds > 0)
|
|
{
|
|
cache.KeyExpire(chiave, DateTime.Now.AddSeconds(expireSeconds));
|
|
}
|
|
//answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redSaveHashDict {exc}");
|
|
}
|
|
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 (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"redSaveHashList {exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce info dei server connessi...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public IServer[] redServInfo()
|
|
{
|
|
IServer[] answ = new IServer[1];
|
|
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)
|
|
{
|
|
Logging.Instance.Error($"redServInfo {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conteggio elementi in QUEUE (LIFO)
|
|
/// </summary>
|
|
/// <param name="queueName"></param>
|
|
/// <param name="value"></param>
|
|
public long redStackCount(RedisKey queueName)
|
|
{
|
|
return cache.ListLength(queueName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupero valore in STACK (LIFO)
|
|
/// </summary>
|
|
/// <param name="stackName"></param>
|
|
/// <returns></returns>
|
|
public RedisValue redStackPop(RedisKey stackName)
|
|
{
|
|
return cache.ListRightPop(stackName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scrittura valore in STACK (LIFO)
|
|
/// </summary>
|
|
/// <param name="stackName"></param>
|
|
/// <param name="value"></param>
|
|
public void redStackPush(RedisKey stackName, RedisValue value)
|
|
{
|
|
cache.ListRightPush(stackName, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resetta (elimina) un contatore in Redis
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public bool resetRCnt(string chiave)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = cache.KeyDelete(chiave);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"resetRCnt {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invia un messaggio tramite notify channel + salva in cache (se scaduto periodo veto)
|
|
/// </summary>
|
|
/// <param name="memKey"></param>
|
|
/// <param name="notifyChannel"></param>
|
|
/// <param name="message"></param>
|
|
/// <returns></returns>
|
|
public bool saveAndSendMessage(string memKey, string notifyChannel, string message)
|
|
{
|
|
bool fatto = false;
|
|
// effettuo la scrittura nell'area di memoria indicata SE passato intervallo minimo di 5 sec
|
|
bool doSave = true;
|
|
if (LastKeySave.ContainsKey(memKey))
|
|
{
|
|
if (DateTime.Now.Subtract(LastKeySave[memKey]).TotalSeconds < 5)
|
|
{
|
|
doSave = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LastKeySave.Add(memKey, DateTime.Now);
|
|
}
|
|
if (doSave)
|
|
{
|
|
cache.StringSet(memKey, message);
|
|
LastKeySave[memKey] = DateTime.Now;
|
|
Logging.Instance.Trace($"Redis Cache Key saved: {memKey}");
|
|
}
|
|
|
|
// invio notifica tramite il canale richiesto
|
|
RedisChannel pubNotifyChannel = new RedisChannel(notifyChannel, RedisChannel.PatternMode.Literal);
|
|
messageDisp.Publish(pubNotifyChannel, message);
|
|
fatto = true;
|
|
// restituisco!
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializzazione di un oggetto generico
|
|
/// </summary>
|
|
/// <param name="origVal"></param>
|
|
/// <returns></returns>
|
|
public string serializeVal(object origVal)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = JsonConvert.SerializeObject(origVal);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"serializeVal {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public bool setKReqCount(string keyReq, int val)
|
|
{
|
|
string keyReqHash = redHash($"IOB:{currCodIob}:KRCOUNT:{keyReq}");
|
|
// salvo ogni chiave x 25 h (in sec 60*60*25)
|
|
bool done = setRSV(keyReqHash, $"{val}", 60 * 60 * 25);
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decrementa un contatore in Redis
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public long setRCntD(string chiave)
|
|
{
|
|
long answ = 0;
|
|
try
|
|
{
|
|
answ = cache.StringDecrement(chiave, 1);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"setRCntD {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Incrementa un contatore in Redis
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public long setRCntI(string chiave)
|
|
{
|
|
long answ = 0;
|
|
try
|
|
{
|
|
answ = cache.StringIncrement(chiave, 1);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"setRCntI {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
|
|
{
|
|
cache.StringSet(valori);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"setRKeys {exc}");
|
|
}
|
|
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;
|
|
try
|
|
{
|
|
cache.StringSet(chiave, valore);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"setRSV {exc}");
|
|
}
|
|
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;
|
|
try
|
|
{
|
|
TimeSpan expT = new TimeSpan(0, 0, TTL_sec);
|
|
// salvo con expyry...
|
|
cache.StringSet(chiave, valore, expT);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Logging.Instance.Error($"setRSV {exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Registra un nuovo evento di scambio dati su redis
|
|
/// </summary>
|
|
/// <param name="rkeyTS">Chiave ZSet eventi tracciati per recupero recenti</param>
|
|
/// <param name="rkeyHash">Chiave hashset valore eventi</param>
|
|
/// <param name="dataQty">Quantità di dati scambiati (byte)</param>
|
|
/// <returns>L'ID univoco dell'evento generato.</returns>
|
|
public string TrackExchData(string rkeyTS, string rkeyHash, long dataQty)
|
|
{
|
|
// Usa un timestamp in millisecondi per maggiore granularità e corrispondenza con JS/Java
|
|
long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
string eventId = Guid.NewGuid().ToString(); // Genera un ID univoco
|
|
|
|
// Aggiungi al Sorted Set: score = timestamp, member = eventId
|
|
cache.SortedSetAdd(rkeyTS, eventId, timestamp);
|
|
|
|
// Memorizza i dettagli nella Hash Table: field = eventId, value = dataQty
|
|
cache.HashSet(rkeyHash, eventId, dataQty.ToString());
|
|
|
|
return eventId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Registra un nuovo evento di scambio dati su redis
|
|
/// </summary>
|
|
/// <param name="rkeyTS">Chiave ZSet eventi tracciati per recupero recenti</param>
|
|
/// <param name="rkeyHash">Chiave hashset valore eventi</param>
|
|
/// <param name="dataQty">Quantità di dati scambiati (byte)</param>
|
|
/// <returns>L'ID univoco dell'evento generato.</returns>
|
|
public async Task<string> TrackExchDataAsync(string rkeyTS, string rkeyHash, long dataQty)
|
|
{
|
|
// Usa un timestamp in millisecondi per maggiore granularità e corrispondenza con JS/Java
|
|
long timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
|
|
string eventId = Guid.NewGuid().ToString(); // Genera un ID univoco
|
|
|
|
// Aggiungi al Sorted Set: score = timestamp, member = eventId
|
|
await cache.SortedSetAddAsync(rkeyTS, eventId, timestamp);
|
|
|
|
// Memorizza i dettagli nella Hash Table: field = eventId, value = dataQty
|
|
await cache.HashSetAsync(rkeyHash, eventId, dataQty.ToString());
|
|
|
|
#if false
|
|
// Crea un batch per eseguire le operazioni in modo transazionale
|
|
var batch = cache.CreateBatch();
|
|
|
|
// Aggiungi al Sorted Set: score = timestamp, member = eventId
|
|
await batch.SortedSetAddAsync(EventsTimeSeriesKey, eventId, timestamp);
|
|
|
|
// Memorizza i dettagli nella Hash Table: field = eventId, value = dataExchanged
|
|
await batch.HashSetAsync(EventDetailsHashKey, eventId, dataExchanged.ToString()); // StackExchange.Redis memorizza RedisValue
|
|
|
|
// Esegui il batch in modo sincrono (o non va...)
|
|
batch.Execute();
|
|
//await batch.ExecuteAsync();
|
|
#endif
|
|
|
|
Logging.Instance.Debug($"Evento registrato: ID={eventId}, Timestamp={timestamp}, Dati={dataQty}");
|
|
return eventId;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
/// <summary>
|
|
/// Cod IOB
|
|
/// </summary>
|
|
protected string currCodIob = "000";
|
|
|
|
/// <summary>
|
|
/// Tipo IOB
|
|
/// </summary>
|
|
protected string currIobType = "ND";
|
|
|
|
/// <summary>
|
|
/// Nome del channel REDIS x dati IOB
|
|
/// </summary>
|
|
protected string redIobChannel = "IobChannel";
|
|
|
|
/// <summary>
|
|
/// Hash REDIS x dati IOB
|
|
/// </summary>
|
|
protected string redIobKey = "";
|
|
|
|
/// <summary>
|
|
/// Hash REDIS x dati server
|
|
/// </summary>
|
|
protected string redServKey = "";
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Dizionario delle ultime scritture in cache redis dei messaggi
|
|
/// </summary>
|
|
private Dictionary<string, DateTime> LastKeySave = new Dictionary<string, DateTime>();
|
|
|
|
/// <summary>
|
|
/// Connessione lazy a redis...
|
|
/// </summary>
|
|
private Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
|
|
{
|
|
string RedisConn = baseUtils.CRS("RedisConn");
|
|
if (string.IsNullOrEmpty(RedisConn))
|
|
{
|
|
RedisConn = "localhost,abortConnect=false,ssl=false";
|
|
}
|
|
|
|
return ConnectionMultiplexer.Connect(RedisConn);
|
|
});
|
|
|
|
/// <summary>
|
|
/// Connessione lazy a redis...
|
|
/// </summary>
|
|
private Lazy<ConnectionMultiplexer> lazyConnectionAdmin = new Lazy<ConnectionMultiplexer>(() =>
|
|
{
|
|
string RedisConnAdmin = baseUtils.CRS("RedisConnAdmin");
|
|
if (string.IsNullOrEmpty(RedisConnAdmin))
|
|
{
|
|
RedisConnAdmin = "localhost,abortConnect=false,ssl=false,allowAdmin=true";
|
|
}
|
|
|
|
return ConnectionMultiplexer.Connect(RedisConnAdmin);
|
|
});
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
/// <summary>
|
|
/// Oggetto currentDb REDIS locale
|
|
/// </summary>
|
|
private IDatabase _currDB { get; set; }
|
|
|
|
/// <summary>
|
|
/// Oggetto subscriber x pubblicazione/sottoscrizione canali REDIS
|
|
/// </summary>
|
|
private ISubscriber _currSub { get; set; }
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
/// <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 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);
|
|
}
|
|
|
|
private void initMemKeys()
|
|
{
|
|
// init dati di base...
|
|
redServKey = redHash($"MP");
|
|
redIobKey = redHash($"IOB:{currCodIob}");
|
|
redIobTrackKey = redHash($"IOB:FluxLog:{currCodIob}");
|
|
redIobChannel = $"IobChannel_{currCodIob}";
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |