Egalware/lux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Aggiunta metodi RedisService x ProdService

Browse Source
This commit is contained in:
Samuele Locatelli
2026-03-24 18:58:04 +01:00
parent 9fe3f55843
commit 1f2a89e6f0
3 changed files with 196 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgwCoreLib.Lux.Data/Services/General/IRedisService.cs
+148
View File
@@ -9,56 +9,204 @@ namespace EgwCoreLib.Lux.Data.Services.General
{
#region Public Methods
/// <summary>
/// Eliminazione chiave su cache REDIS in modalità Async
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
bool Delete(string key);
/// <summary>
/// Eliminazione chiave su cache REDIS in modalità Async
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
Task<bool> DeleteAsync(string key);
/// <summary>
/// Elimina chiavi Redis che corrispondono al pattern specificato
/// </summary>
/// <param name="pattern">Pattern di ricerca (es. "Lux:*" o "*")</param>
/// <returns>true se eliminazione completata, false altrimenti</returns>
Task<bool> FlushPatternAsync(RedisValue pattern);
/// <summary>
/// Recupero stringa da cache REDIS x key indicata in modalità Async
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
string? Get(string key);
/// <summary>
/// Recupero stringa da cache REDIS x key indicata in modalità Async
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
Task<string?> GetAsync(string key);
/// <summary>
/// Recupera un campo specifico da una hash REDIS
/// </summary>
/// <param name="hashKey">Chiave della hash</param>
/// <param name="field">Campo da recuperare</param>
/// <returns>Valore del campo, o RedisValue.Null se non esiste</returns>
Task<RedisValue?> HashGetAsync(string hashKey, string field);
/// <summary>
/// Recupera TUTTI i campi e valori da una hash REDIS
/// </summary>
/// <param name="hashKey">Chiave della hash</param>
/// <returns>Elenco completo di campi e valori, o lista vuota se non esiste</returns>
Task<List<HashEntry>> HashGetAllAsync(string hashKey);
/// <summary>
/// Pubblicazione messaggio su channel
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
long Publish(string channel, string message);
/// <summary>
/// Pubblicazione messaggio su channel in modalità async
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
Task<long> PublishAsync(string channel, string message);
/// <summary>
/// Conteggio elementi in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
long QueueCount(RedisKey queueName);
/// <summary>
/// Conteggio elementi in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
Task<long> QueueCountAsync(RedisKey queueName);
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
List<RedisValue> QueueListAll(RedisKey queueName);
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
Task<List<RedisValue>> QueueListAllAsync(RedisKey queueName);
/// <summary>
/// Recupero valore in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
RedisValue QueuePop(RedisKey queueName);
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda
/// </summary>
/// <param name="queueName"></param>
List<RedisValue> QueuePopAll(RedisKey queueName);
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda in modo Async
/// </summary>
/// <param name="queueName"></param>
Task<List<RedisValue>> QueuePopAllAsync(RedisKey queueName);
/// <summary>
/// Recupero valore in QUEUE (FIFO) Async
/// </summary>
/// <param name="queueName"></param>
Task<RedisValue> QueuePopAsync(RedisKey queueName);
/// <summary>
/// Recupero una list di valori in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
List<RedisValue> QueuePopList(RedisKey queueName, int maxElem);
/// <summary>
/// Recupero una list di valori in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
Task<List<RedisValue>> QueuePopListAsync(RedisKey queueName, int maxElem);
/// <summary>
/// Scrittura valore in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
/// <param name="value"></param>
long QueuePush(RedisKey queueName, RedisValue value);
/// <summary>
/// Scrittura valore in QUEUE (FIFO)
/// </summary>
/// <param name="queueName"></param>
/// <param name="value"></param>
Task<long> QueuePushAsync(RedisKey queueName, RedisValue value);
/// <summary>
/// Rimuove un valore specifico dalla queue Redis (FIFO)
/// </summary>
/// <param name="queueName">Nome della lista</param>
/// <param name="value">Valore da rimuovere</param>
/// <returns>Numero di elementi rimossi</returns>
long QueueRemove(RedisKey queueName, RedisValue value);
/// <summary>
/// Rimuove un valore specifico dalla queue Redis (FIFO) Async
/// </summary>
/// <param name="queueName">Nome della lista</param>
/// <param name="value">Valore da rimuovere</param>
/// <returns>Numero di elementi rimossi</returns>
Task<long> QueueRemoveAsync(RedisKey queueName, RedisValue value);
/// <summary>
/// Reset della coda
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
bool QueueReset(RedisKey queueName);
/// <summary>
/// Reset della coda Async
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
Task<bool> QueueResetAsync(RedisKey queueName);
/// <summary>
/// Scrittura string su cache REDIS in modalità Async
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="tsExpiry"></param>
/// <returns></returns>
bool Set(string key, string value, TimeSpan? expiry = null);
/// <summary>
/// Scrittura string su cache REDIS in modalità Async
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="tsExpiry"></param>
/// <returns></returns>
Task<bool> SetAsync(string key, string value, TimeSpan? expiry = null);
/// <summary>
/// Sottoscrizione canale REDIS + handler esecuzione
/// </summary>
/// <param name="channel"></param>
/// <param name="handler"></param>
void Subscribe(string channel, Action<RedisChannel, RedisValue> handler);
#endregion Public Methods
EgwCoreLib.Lux.Data/Services/General/ProdService.cs
+3 -5
View File
@@ -19,7 +19,6 @@ namespace EgwCoreLib.Lux.Data.Services.General
{
// conf redis service
_redisService = redisService;
_db = _redisConn.GetDatabase();
chPub = _config.GetValue<string>("ServerConf:ChannelPub") ?? "";
Log.Info($"ProdService | Init OK");
}
@@ -300,13 +299,13 @@ namespace EgwCoreLib.Lux.Data.Services.General
public async Task UpdateQueueAsync(Constants.EXECENVIRONMENTS cEnvir, string hashKey)
{
// recupero info accessorie da redis
var tipo = await _db.HashGetAsync(hashKey, "tipo");
var tipo = await _redisService.HashGetAsync(hashKey, "tipo");
// verifico SE si tratta di un create/estimate e nel caso processo coda req x sistemare
if (!tipo.IsNull && !string.IsNullOrEmpty(tipo))
if (tipo != null && !string.IsNullOrEmpty(tipo))
{
string rKey = "";
var UID = await _db.HashGetAsync(hashKey, "UID");
var UID = await _redisService.HashGetAsync(hashKey, "UID");
var parti = ((string)tipo).Split('-');
if (parti.Length == 2)
{
@@ -347,7 +346,6 @@ namespace EgwCoreLib.Lux.Data.Services.General
#region Private Fields
private static Logger Log = LogManager.GetCurrentClassLogger();
private readonly IDatabase _db;
private readonly IRedisService _redisService;
private readonly string chPub = "";
EgwCoreLib.Lux.Data/Services/General/RedisService.cs
+45 -82
View File
@@ -32,10 +32,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
#region Public Methods
/// <summary>
/// Eliminazione chiave su cache REDIS in modalità Async
/// <inheritdoc />
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool Delete(string key)
{
Log.Trace($"Set request for {key}");
@@ -43,10 +41,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Eliminazione chiave su cache REDIS in modalità Async
/// <inheritdoc />
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<bool> DeleteAsync(string key)
{
Log.Trace($"SetAsync request for {key}");
@@ -54,10 +50,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Elimina chiavi Redis che corrispondono al pattern specificato
/// <inheritdoc />
/// </summary>
/// <param name="pattern">Pattern di ricerca (es. "Lux:*" o "*")</param>
/// <returns>true se eliminazione completata, false altrimenti</returns>
public async Task<bool> FlushPatternAsync(RedisValue pattern)
{
try
@@ -105,10 +99,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero stringa da cache REDIS x key indicata in modalità Async
/// <inheritdoc />
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string? Get(string key)
{
Log.Trace($"Get request for {key}");
@@ -117,10 +109,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero stringa da cache REDIS x key indicata in modalità Async
/// <inheritdoc />
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<string?> GetAsync(string key)
{
Log.Trace($"GetAsync request for {key}");
@@ -129,11 +119,27 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Pubblicazione messaggio su channel
/// <inheritdoc />
/// </summary>
public async Task<List<HashEntry>> HashGetAllAsync(string hashKey)
{
Log.Trace($"HashGetAllAsync request for {hashKey}");
var results = await _db.HashGetAllAsync(hashKey);
return results.ToList();
}
/// <summary>
/// <inheritdoc />
/// </summary>
public async Task<RedisValue?> HashGetAsync(string hashKey, string field)
{
Log.Trace($"HashGetAsync request for {hashKey}.{field}");
return await _db.HashGetAsync(hashKey, field);
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
public long Publish(string channel, string message)
{
Log.Trace($"Publish: channel {channel}");
@@ -143,11 +149,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Pubblicazione messaggio su channel in modalità async
/// <inheritdoc />
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task<long> PublishAsync(string channel, string message)
{
Log.Trace($"PublishAsync: channel {channel}");
@@ -157,28 +160,24 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Conteggio elementi in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
public long QueueCount(RedisKey queueName)
{
return _db.ListLength(queueName);
}
/// <summary>
/// Conteggio elementi in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
public async Task<long> QueueCountAsync(RedisKey queueName)
{
return await _db.ListLengthAsync(queueName);
}
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
public List<RedisValue> QueueListAll(RedisKey queueName)
{
// lettura + reset in blocco
@@ -187,10 +186,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) senza eliminare
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
public async Task<List<RedisValue>> QueueListAllAsync(RedisKey queueName)
{
// lettura + reset in blocco
@@ -199,19 +196,16 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero valore in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
public RedisValue QueuePop(RedisKey queueName)
{
return _db.ListLeftPop(queueName);
}
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
public List<RedisValue> QueuePopAll(RedisKey queueName)
{
// lettura + reset in blocco
@@ -224,10 +218,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero list di TUTTI i valori in QUEUE (FIFO) eliminandoli dalla coda in modo Async
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
public async Task<List<RedisValue>> QueuePopAllAsync(RedisKey queueName)
{
// lettura + reset in blocco
@@ -241,19 +233,16 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero valore in QUEUE (FIFO) Async
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
public async Task<RedisValue> QueuePopAsync(RedisKey queueName)
{
return await _db.ListLeftPopAsync(queueName);
}
/// <summary>
/// Recupero una list di valori in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
public List<RedisValue> QueuePopList(RedisKey queueName, int maxElem)
{
// nuovo metodo con rimozione
@@ -268,10 +257,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Recupero una list di valori in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="maxElem">num max di elementi da recuperare</param>
public async Task<List<RedisValue>> QueuePopListAsync(RedisKey queueName, int maxElem)
{
// nuovo metodo con rimozione
@@ -286,10 +273,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Scrittura valore in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="value"></param>
public long QueuePush(RedisKey queueName, RedisValue value)
{
long qLen = _db.ListRightPush(queueName, value);
@@ -297,10 +282,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Scrittura valore in QUEUE (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <param name="value"></param>
public async Task<long> QueuePushAsync(RedisKey queueName, RedisValue value)
{
long qLen = await _db.ListRightPushAsync(queueName, value);
@@ -308,11 +291,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Rimuove un valore specifico dalla queue Redis (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName">Nome della lista</param>
/// <param name="value">Valore da rimuovere</param>
/// <returns>Numero di elementi rimossi</returns>
public long QueueRemove(RedisKey queueName, RedisValue value)
{
// count = 0 → rimuove TUTTE le occorrenze del valore
@@ -320,11 +300,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Rimuove un valore specifico dalla queue Redis (FIFO)
/// <inheritdoc />
/// </summary>
/// <param name="queueName">Nome della lista</param>
/// <param name="value">Valore da rimuovere</param>
/// <returns>Numero di elementi rimossi</returns>
public async Task<long> QueueRemoveAsync(RedisKey queueName, RedisValue value)
{
// count = 0 → rimuove TUTTE le occorrenze del valore
@@ -332,10 +309,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Reset della coda
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
public bool QueueReset(RedisKey queueName)
{
bool answ = _db.KeyDelete(queueName);
@@ -343,10 +318,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Reset della coda
/// <inheritdoc />
/// </summary>
/// <param name="queueName"></param>
/// <returns></returns>
public async Task<bool> QueueResetAsync(RedisKey queueName)
{
bool answ = await _db.KeyDeleteAsync(queueName);
@@ -354,12 +327,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Scrittura string su cache REDIS in modalità Async
/// <inheritdoc />
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="tsExpiry"></param>
/// <returns></returns>
public bool Set(string key, string value, TimeSpan? tsExpiry = null)
{
Log.Trace($"Set request for {key}");
@@ -367,12 +336,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Scrittura string su cache REDIS in modalità Async
/// <inheritdoc />
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="tsExpiry"></param>
/// <returns></returns>
public async Task<bool> SetAsync(string key, string value, TimeSpan? tsExpiry = null)
{
Log.Trace($"SetAsync request for {key}");
@@ -380,10 +345,8 @@ namespace EgwCoreLib.Lux.Data.Services.General
}
/// <summary>
/// Sottoscrizione canale REDIS + handler esecuzione
/// <inheritdoc />
/// </summary>
/// <param name="channel"></param>
/// <param name="handler"></param>
public void Subscribe(string channel, Action<RedisChannel, RedisValue> handler)
{
Log.Trace($"Subscribed to channel {channel}");