protected override async Task OnMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs e)
{
byte[] packet = e.ApplicationMessage.Payload;
string txt = Encoding.UTF8.GetString(packet);
try
{
EventModel data = JsonConvert.DeserializeObject <EventModel>(txt);
using (var session = sessionFactory.OpenStatelessSession())
using (var transaction = session.BeginTransaction())
{
EventMap map = session.Get <EventMap>(data.EventCode);
string redisKey = $"SID{data.SiteId}.EVENT.{data.DeviceId}";
Program.logger.Info($"Received Event: {data.EventCode} / Status: {data.Status}");
switch (data.Status)
{
case EventStatus.New:
await redisDb.HashSetAsync(redisKey, $"{data.EventCode}", bool.TrueString);
// 새로 발생한 이벤트
IList <EventRecord> ev = await FindNewRaiseEvent(data.EventCode, session.CreateCriteria <EventRecord>());
if (ev.Count > 0)
{
return;
}
EventRecord newEventRecode = new EventRecord();
newEventRecode.CreateDT = new DateTime(1970, 1, 1).AddSeconds(data.UnixTimestamp).ToLocalTime();
newEventRecode.EventId = data.EventCode;
newEventRecode.SiteId = data.SiteId;
newEventRecode.DeviceId = data.DeviceId;
await session.InsertAsync(newEventRecode);
break;
case EventStatus.Recovery:
await redisDb.HashSetAsync(redisKey, $"{data.EventCode}", bool.FalseString);
var rc_result = await FindNewRaiseEvent(data.EventCode, session.CreateCriteria <EventRecord>());
if (rc_result.Count > 0)
{
foreach (EventRecord exist_record in rc_result)
{
exist_record.RecoveryDT = new DateTime(1970, 1, 1).AddSeconds(data.UnixTimestamp).ToLocalTime();
await session.UpdateAsync(exist_record);
}
}
break;
}
await transaction.CommitAsync();
}
}
catch (Exception ex)
{
Program.logger.Error(ex, ex.Message);
}
}
/// <summary>
/// Sends raw announcement.
/// </summary>
/// <param name="payload">The raw announcement data.</param>
/// <returns>
/// Return the message id
/// </returns>
public async ValueTask <string> SendAsync(Announcement payload)
{
IDatabaseAsync db = await _dbTask;
Metadata meta = payload.Metadata;
string id = meta.MessageId;
#region var entries = new NameValueEntry[]{...}
// local method
NameValueEntry KV(RedisValue key, RedisValue value) => new NameValueEntry(key, value);
var entries = new NameValueEntry[]
{
KV(nameof(meta.MessageId), id),
KV(nameof(meta.Operation), meta.Operation),
KV(nameof(meta.ProducedAt), meta.ProducedAt.ToUnixTimeSeconds())
};
#endregion // var entries = new NameValueEntry[]{...}
// TODO: [bnaya 2021-01] enable to replace the segments storage without replacing the strweam
#region await db.HashSetAsync($"Segments~{id}", segmentsEntities)
var segmentsEntities = payload.Segments
.Select(sgm =>
new HashEntry(sgm.Key, sgm.Value))
.ToArray();
await db.HashSetAsync($"Segments~{id}", segmentsEntities);
#endregion // await db.HashSetAsync($"Segments~{id}", segmentsEntities)
#region await db.HashSetAsync($"Interceptors~{id}", interceptionsEntities)
var interceptionsEntities = payload.InterceptorsData
.Select(spt =>
new HashEntry(spt.Key, spt.Value))
.ToArray();
await db.HashSetAsync($"Interceptors~{id}", interceptionsEntities);
#endregion // await db.HashSetAsync($"Interceptors~{id}", interceptionsEntities)
RedisValue messageId = await _resiliencePolicy.ExecuteAsync(() =>
db.StreamAddAsync(meta.Key(), entries,
flags: CommandFlags.DemandMaster));
return(messageId);
}
public Task AddRecord(IDatabaseAsync database, IDataKey objectKey, params T[] instances)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
if (objectKey == null)
{
throw new ArgumentNullException(nameof(objectKey));
}
if (instances == null)
{
throw new ArgumentNullException(nameof(instances));
}
log.LogDebug("AddRecords: {0}", instances.Length);
if (instances.Length > 1)
{
throw new ArgumentOutOfRangeException();
}
var instance = instances[0];
var tasks = new List <Task>();
var actualKey = link.GetKey(objectKey);
var entries = objectSerialization.GetEntries(instance).ToArray();
tasks.Add(database.HashSetAsync(actualKey, entries));
tasks.AddRange(mainIndexManager.Add(database, objectKey));
return(Task.WhenAll(tasks));
}
protected override async Task OnApplicationMessageReceived(string ClientId, string Topic, string ContentType, uint QosLevel, byte[] payload)
{
try
{
string data = Encoding.UTF8.GetString(payload);
JObject jObj = JObject.Parse(data);
int groupId = jObj["groupid"].Value <int>();
int siteId = jObj["siteId"].Value <int>();
string deviceId = jObj["normalizedeviceid"].Value <string>();
string redisKey = CommonFactory.CreateRedisKey(siteId, groupId, deviceId);
HashEntry[] hashValues = CreateHashEntry(jObj);
await db.HashSetAsync(redisKey, hashValues);
//if(groupId == 4) // PV일 경우
//{
// float totalActivePower = jObj["EnergyTotalActivePower"].Value<float>();
// string sub_redis_key = CommonFactory.CreateRedisKey(siteId, groupId, "EnergyTotalActivePower");
// int deviceIndex = int.Parse(deviceId.TrimStart("PV".ToCharArray()));
// if(await db.KeyExistsAsync(sub_redis_key) == false)
// {
// await db.ListLeftPushAsync(sub_redis_key, new RedisValue[] { 0, 0, 0, 0 });
// }
// await db.ListSetByIndexAsync(sub_redis_key, deviceIndex - 1, totalActivePower);
//}
}
catch (Exception ex)
{
logger.LogError(ex, "Method: OnApplicationMessageReceived\n" + ex.Message);
}
}
public async Task <bool> HashSetAsync(RedisKey key, RedisValue hashField, RedisValue value, TimeSpan?expiry = null, When when = When.Always)
{
key = $"{productID}_{key}";
IDatabaseAsync db = null;
ITransaction context = CallContext.GetData(KEY_WORD_REDIS_CONTEXT) as ITransaction;
if (context == null)
{
db = Database();
if (db == null)
{
return(false);
}
}
else
{
db = context;
}
UsingCount();
bool is_success = await db.HashSetAsync(key, hashField, value, when);
if (expiry != null)
{
await db.KeyExpireAsync(key, expiry);
}
return(is_success);
}
public async Task <bool> UpsertPollSummary(PollSummary summary)
{
try
{
var memoryStream = new MemoryStream();
using (var outputStream = new Google.Protobuf.CodedOutputStream(memoryStream))
{
summary.WriteTo(outputStream);
}
var summaryData = memoryStream.ToArray();
var pollId = summary.Poll?.Id;
if (pollId == null || pollId == "")
{
return(false);
}
var response = await _database.HashSetAsync(PollSummaryHashKey, pollId, summaryData, When.Always);
var didPublish = await _pubSub.PublishUpdate(summary);
return(didPublish);
}
catch (Exception e)
{
_logger.LogError(e, "Error while poll summary to database");
return(false);
}
}
public async Task WriteAsync(string databaseKey, JobModel job)
{
var data = await Task.Run(() =>
JsonConvert.SerializeObject(job, Formatting.None)).ConfigureAwait(false);
await _redis.HashSetAsync(databaseKey, job.JobId, data).ConfigureAwait(false);
}
private static async Task UpdateRowCacheInRedis(IDatabaseAsync db, RootIndexRow row)
{
var redisSetKey = GetRedisKeyForColumn(row.ColumnName);
var redisFilesToValuesKey = GetRedisFilesToValuesKeyForColumn(row.ColumnName);
var redisValuesToFilesKey = GetRedisValuesToFilesKeyForColumn(row.ColumnName);
var currentMaxValue = await db.HashGetAsync(redisFilesToValuesKey, row.FileName);
if (currentMaxValue != default)
{
await db.HashDeleteAsync(redisValuesToFilesKey, currentMaxValue);
await db.SortedSetRemoveAsync(redisSetKey, currentMaxValue);
}
await db.HashSetAsync(redisValuesToFilesKey, row.FileName, row.Max);
await db.HashSetAsync(redisValuesToFilesKey, row.Max, row.FileName);
await db.SortedSetAddAsync(redisSetKey, row.Max, 0);
}
public override void Set(
IDatabaseAsync context,
IEnumerable <TValue> items
)
{
var indexName = _indexCollectionName;
context.HashSetAsync(indexName, items.ToHashEntries(IndexedKeyExtractor.ExtractKey, IndexedValueExtractor));
if (Expiry.HasValue)
{
context.KeyExpireAsync(indexName, Expiry);
}
}
private static async Task SyncRedisKeyAsync(IDatabaseAsync srcDatabase, RedisKey redisKey, IDatabaseAsync destDatabase)
{
if (await destDatabase.KeyExistsAsync(redisKey))
{
await destDatabase.KeyDeleteAsync(redisKey);
}
var type = await srcDatabase.KeyTypeAsync(redisKey);
switch (type)
{
case RedisType.String:
var strVal = await srcDatabase.StringGetAsync(redisKey);
await destDatabase.StringSetAsync(redisKey, strVal);
break;
case RedisType.List:
var list = await srcDatabase.ListRangeAsync(redisKey);
await destDatabase.ListRightPushAsync(redisKey, list);
break;
case RedisType.Set:
var set = await srcDatabase.SetMembersAsync(redisKey);
await destDatabase.SetAddAsync(redisKey, set);
break;
case RedisType.SortedSet:
var zset = await srcDatabase.SortedSetRangeByRankWithScoresAsync(redisKey);
await destDatabase.SortedSetAddAsync(redisKey, zset);
break;
case RedisType.Hash:
var hash = await srcDatabase.HashGetAllAsync(redisKey);
await destDatabase.HashSetAsync(redisKey, hash);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("execute worker");
string target_ip = Environment.GetEnvironmentVariable("UDP_TARGET_IP");
string target_port = Environment.GetEnvironmentVariable("UDP_TARGET_PORT");
_logger.LogInformation("Target UDP Server: {0} : {1}", target_ip, target_port);
int portNum = 11000;
int.TryParse(target_port, out portNum);
while (!stoppingToken.IsCancellationRequested)
{
try
{
//_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
JObject jObj = await packetQueue.DequeueAsync(stoppingToken);
int groupId = jObj["groupid"].Value <int>();
int siteId = jObj["siteId"].Value <int>();
string deviceId = jObj["normalizedeviceid"].Value <string>();
//if (groupId == 4 && siteId == 6)
//{
// PvPacket packet = ConvertPacket(jObj);
// int packSize = packet.GetSize();
// var pack = packet.ToByteArray();
// int packLength = pack.Length;
// int sendpackets = udpClient.Send(pack, packLength, target_ip, portNum);
// _logger.LogInformation("SENDING PACKET ({0} bytes)", sendpackets);
//}
string redisKey = CreateRedisKey(siteId, groupId, deviceId);
HashEntry[] hashValues = CreateHashEntry(jObj);
await db.HashSetAsync(redisKey, hashValues);
await Task.Delay(100, stoppingToken);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
}
protected virtual Task AddManyLoginsAsync(TUser user, IEnumerable <UserLoginInfo> logins, ITransaction transaction = null)
{
Contract.Requires(logins != null && logins.Count() > 0);
IDatabaseAsync db = transaction == null ? Database : (IDatabaseAsync)transaction;
Task setTask = db.SetAddAsync
(
string.Format(UserLoginSetKey, ((IUser)user).Id),
logins.Select(login => (RedisValue)JsonConvert.SerializeObject(login)).ToArray()
);
Task hashTask = db.HashSetAsync
(
UserLoginHashKey,
logins.Select(login => new HashEntry(string.Format("{0}:{1}", login.LoginProvider, login.ProviderKey), ((IUser)user).Id)).ToArray()
);
return(Task.WhenAll(setTask, hashTask));
}
public Task <bool> HashSetAsync(RedisKey key, RedisValue hashField, RedisValue value, When when = When.Always)
{
IDatabaseAsync db = null;
ITransaction context = CallContext.GetData(KEY_WORD_REDIS_CONTEXT) as ITransaction;
if (context == null)
{
db = Database();
if (db == null)
{
return(Task.FromResult(false));
}
}
else
{
db = context;
}
UsingCount();
return(db.HashSetAsync(key, hashField, value, when));
}
public async Task <IActionResult> GetEventMapList(int siteid, string source, int count)
{
using (var session = peiuGridDataContext.SessionFactory.OpenStatelessSession())
{
var map_row = await session.CreateCriteria <EventMap>()
.Add(Restrictions.Eq("Source", source))
.ListAsync <EventMap>();
foreach (EventMap map in map_row)
{
for (int idx = 1; idx <= count; idx++)
{
string redisKey = $"SID{siteid}.EVENT.{source}{idx}";
if (await db.HashExistsAsync(redisKey, map.EventId) == false)
{
await db.HashSetAsync(redisKey, map.EventId, bool.FalseString);
}
}
}
}
return(Ok());
}
/// <summary>
/// Using HashSetAsync
/// </summary>
/// <param name="db"></param>
/// <returns></returns>
private static async Task GenerateClocks(IDatabaseAsync db)
{
var sw = Stopwatch.StartNew();
var random = new Random();
for (var i = 0; i < Total; i++)
{
var id = $"GT-{i}";
var clock = new ClockInfo
{
DeviceId = id,
SerialNumber = id.ToLower(),
ClientId = random.Next(10000, 99999),
ClockGroupId = Guid.NewGuid()
};
await db.HashSetAsync($"clock:{id}", clock.ToHashEntries());
await db.KeyExpireAsync($"clock:{id}", DateTime.Now.AddMinutes(5));
}
Console.WriteLine(
$"Storing {Total} Using original HashSetAsync (v1): {Math.Round(sw.Elapsed.TotalMilliseconds, 3)}ms");
}
//private async Task SendQueue(string topic, JObject msg_oridinary, CancellationToken token)
//{
// foreach (var mqtt_proxy in mqtt_clients)
// {
// try
// {
// var msg = CreateMqttMessage(topic, msg_oridinary.ToString(), mqtt_proxy.Options.QosLevel);
// var mqtt_client = mqtt_proxy.MqttClient;
// if (mqtt_client.IsConnected == false)
// continue;
// await mqtt_client.PublishAsync(msg, token);
// Thread.Sleep(10);
// break;
// }
// catch (Exception ex)
// {
// logger.LogError(ex, ex.Message);
// }
// }
//}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
stoppingToken.ThrowIfCancellationRequested();
try
{
bool isConnected = modbusFactory.ReconnectWhenDisconnected(stoppingToken, 3);
if (isConnected == false)
{
logger.LogWarning("모드버스 접속에 실패했습니다. 5초후 재개");
await Task.Delay(5000, stoppingToken);
continue;
}
stoppingToken.ThrowIfCancellationRequested();
//var parallelResult = Parallel.ForEach<GroupPoint>(modbus.GroupPoints, (async x =>
foreach (var x in modbus.GroupDigitalPoints)
{
if (x.Disable == true)
{
continue;
}
List <DiMap> results = await modbusFactory.ReadModbusEvent(x);
foreach (DiMap map in results)
{
if (map.DocumentAddress == 40132)
{
}
if (map.Disable == true)
{
continue;
}
//cache.Get()
//datarow.Add(map.Name, map.Value);
string redis_key = $"{modbus.DeviceName}.{map.DocumentAddress}";
ushort redis_value = 0;
if (await redis.KeyExistsAsync(redis_key))
{
string redis_str = await redis.StringGetAsync(redis_key);
redis_value = ushort.Parse(redis_str);
}
if (map.Value == redis_value)
{
continue;
}
else
{
await redis.StringSetAsync(redis_key, map.Value.ToString());
}
using (var session = dbAccess.SessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
EventSummary summary = new EventSummary();
summary.SiteId = SiteId;
summary.DeviceName = modbus.DeviceName;
summary.GroupName = map.Name;
summary.SetTimestamp(DateTime.Now);
foreach (DiFlag evt in map.Flags)
{
EventField ef = event_map.FirstOrDefault(Tx => Tx.Register == map.DocumentAddress && Tx.BitValue == evt.BitValue);
bool IsActive = evt.IsActivate(map.Value);
if (evt.EventCode.HasValue)
{
summary.ActiveEvents.Add(evt.EventCode.Value);
}
string redis_event_key = redis_key + "." + evt.No;
if (await redis.KeyExistsAsync(redis_event_key) == false)
{
await redis.HashSetAsync(redis_event_key, CreateEventNode(map, evt));
}
else
{
await redis.HashSetAsync(redis_event_key, "Status", IsActive);
}
if (map.Disable == true || map.Level == 0)
{
continue;
}
string mysql_key_str = $"{modbus.DeviceName}{map.DocumentAddress}{evt.No}";
string normalizeDeviceName = map.Source + DeviceIndex;
//ActiveEvent existEvent = session.Get<ActiveEvent>(mysql_key_str);
ActiveEvent existEvent = await GetLatestActiveEventAsync(session, mysql_key_str, stoppingToken);
//if (existEvent == null)
// continue;
switch (EventStatus(existEvent, IsActive, session))
{
case Hubbub.EventStatus.Already:
mysql_key_str = GetNextEventId(mysql_key_str, session);
existEvent = new ActiveEvent();
existEvent.Description = evt.BitName;
existEvent.DeviceName = modbus.DeviceName;
existEvent.EventLevel = map.Level;
existEvent.EventName = evt.BitName;
existEvent.Source = map.Source;
existEvent.OccurTimestamp = DateTime.Now;
existEvent.EventId = mysql_key_str;
await session.SaveAsync(existEvent, stoppingToken);
break;
case Hubbub.EventStatus.New:
existEvent = new ActiveEvent();
existEvent.Description = evt.BitName;
existEvent.DeviceName = modbus.DeviceName;
existEvent.EventLevel = map.Level;
existEvent.EventName = evt.BitName;
existEvent.Source = map.Source;
existEvent.OccurTimestamp = DateTime.Now;
existEvent.EventId = mysql_key_str;
await session.SaveAsync(existEvent, stoppingToken);
if (evt.EventCode.HasValue)
{
summary.NewEvents.Add(evt.EventCode.Value);
}
if (ef != null)
{
await eventPublisherWorker.PublishEvent(SiteId, normalizeDeviceName, ef.Code, Events.Alarm.EventStatus.New, stoppingToken);
}
break;
case Hubbub.EventStatus.Recover:
if (evt.EventCode.HasValue)
{
summary.RecoverEvents.Add(evt.EventCode.Value);
}
RecoversEvent(existEvent.EventId, session);
if (ef != null)
{
await eventPublisherWorker.PublishEvent(SiteId, normalizeDeviceName, ef.Code, Events.Alarm.EventStatus.Recovery, stoppingToken);
}
//existEvent.HasRecovered = true;
//existEvent.RecoverTimestamp = DateTime.Now;
//await session.SaveOrUpdateAsync(existEvent, stoppingToken);
break;
}
}
await transaction.CommitAsync(stoppingToken);
//var msg = CreateMqttMessage(peiu_event_topic, summary.ToString(), 2);
//await mqtt_clients.PeiuEventBrokerProxy.MqttClient.PublishAsync(msg, stoppingToken);
}
}
}
}
}catch (Exception ex)
{
}
//await SendQueue(peiu_event_topic, datarow, stoppingToken);
await Task.Delay(UpdatePeriod.Milliseconds);
//Thread.Sleep(UpdatePeriod);
}
}
public async ValueTask HashSetAsync(string key, IEnumerable <KeyValuePair <string, string> > keyValuePairs)
{
var hashEntries = keyValuePairs.Select(x => new HashEntry(x.Key, x.Value)).ToArray();
await _database.HashSetAsync(key, hashEntries);
}
public async Task <IActionResult> getcurrenteventstatus(int siteId, string deviceName, int index)
{
try
{
int deviceType = 1;
if (deviceName.ToUpper() == "PCS")
{
deviceType = 1;
}
else if (deviceName.ToUpper() == "BMS")
{
deviceType = 2;
}
else if (deviceName.ToUpper() == "PV")
{
deviceType = 3;
}
else
{
throw new ArgumentException("존재하지 않는 설비명");
}
JArray result = new JArray();
VwContractorsiteEF site_info = await _accountContext.VwContractorsites.FindAsync(siteId);
if (site_info == null)
{
return(BadRequest());
}
using (var session = peiuGridDataContext.SessionFactory.OpenSession())
{
var map_row = await session.CreateCriteria <PEIU.Events.Alarm.ModbusDiMap>()
.Add(Restrictions.Eq("FactoryCode", site_info.DeviceGroupCode) && Restrictions.Eq("DeviceType", deviceType))
.ListAsync <PEIU.Events.Alarm.ModbusDiMap>();
//map_row = await session.CreateCriteria<PEIU.Events.Alarm.ModbusDiMap>().ListAsync<PEIU.Events.Alarm.ModbusDiMap>();
foreach (PEIU.Events.Alarm.ModbusDiMap map in map_row)
{
JObject row = new JObject();
row.Add("code", map.EventCode);
row.Add("name", map.Name);
row.Add("category", map.DeviceType);
row.Add("level", map.Level);
string redisKey = $"SID{siteId}.DI.{deviceType}.{index}";
if (await db.HashExistsAsync(redisKey, map.EventCode))
{
string status = await db.HashGetAsync(redisKey, map.EventCode);
row.Add("status", status);
}
else
{
await db.HashSetAsync(redisKey, map.EventCode, bool.FalseString);
row.Add("status", bool.FalseString);
}
result.Add(row);
}
}
return(Ok(result));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(BadRequest(ex.Message));
}
}
protected override Task AddRawIndex(IDatabaseAsync database, IIndexKey index, string rawKey)
{
var hashIndex = (HashIndexKey)index;
return(database.HashSetAsync(Link.GetIndexKey(index), new[] { new HashEntry(hashIndex.HashKey, rawKey) }));
}
private static TupleList <string, Task> RunStackExchangeAsync(string prefix, IDatabaseAsync db)
{
var tasks = new TupleList <string, Func <Task> >()
{
{ "DebugObjectAsync", () => db.DebugObjectAsync($"{prefix}DebugObjectAsync") },
{ "ExecuteAsync", () => db.ExecuteAsync("DDCUSTOM", "COMMAND") },
{ "GeoAddAsync", () => db.GeoAddAsync($"{prefix}GeoAddAsync", new GeoEntry(1.5, 2.5, "member")) },
{ "GeoDistanceAsync", () => db.GeoDistanceAsync($"{prefix}GeoDistanceAsync", "member1", "member2") },
{ "GeoHashAsync", () => db.GeoHashAsync($"{prefix}GeoHashAsync", "member") },
{ "GeoPositionAsync", () => db.GeoPositionAsync($"{prefix}GeoPositionAsync", "member") },
{ "GeoRadiusAsync", () => db.GeoRadiusAsync($"{prefix}GeoRadiusAsync", "member", 2.3) },
{ "GeoRemoveAsync", () => db.GeoRemoveAsync($"{prefix}GeoRemoveAsync", "member") },
{ "HashDecrementAsync", () => db.HashDecrementAsync($"{prefix}HashDecrementAsync", "hashfield", 4.5) },
{ "HashDeleteAsync", () => db.HashDeleteAsync($"{prefix}HashDeleteAsync", "hashfield") },
{ "HashExistsAsync", () => db.HashExistsAsync($"{prefix}HashExistsAsync", "hashfield") },
{ "HashGetAllAsync", () => db.HashGetAllAsync($"{prefix}HashGetAllAsync") },
{ "HashIncrementAsync", () => db.HashIncrementAsync($"{prefix}HashIncrementAsync", "hashfield", 1.5) },
{ "HashKeysAsync", () => db.HashKeysAsync($"{prefix}HashKeysAsync") },
{ "HashLengthAsync", () => db.HashLengthAsync($"{prefix}HashLengthAsync") },
{ "HashSetAsync", () => db.HashSetAsync($"{prefix}HashSetAsync", new HashEntry[] { new HashEntry("x", "y") }) },
{ "HashValuesAsync", () => db.HashValuesAsync($"{prefix}HashValuesAsync") },
{ "HyperLogLogAddAsync", () => db.HyperLogLogAddAsync($"{prefix}HyperLogLogAddAsync", "value") },
{ "HyperLogLogLengthAsync", () => db.HyperLogLogLengthAsync($"{prefix}HyperLogLogLengthAsync") },
{ "HyperLogLogMergeAsync", () => db.HyperLogLogMergeAsync($"{prefix}HyperLogLogMergeAsync", new RedisKey[] { "key1", "key2" }) },
{ "IdentifyEndpointAsync", () => db.IdentifyEndpointAsync() },
{ "KeyDeleteAsync", () => db.KeyDeleteAsync("key") },
{ "KeyDumpAsync", () => db.KeyDumpAsync("key") },
{ "KeyExistsAsync", () => db.KeyExistsAsync("key") },
{ "KeyExpireAsync", () => db.KeyExpireAsync("key", DateTime.Now) },
// () => db.KeyMigrateAsync("key", ???)
{ "KeyMoveAsync", () => db.KeyMoveAsync("key", 1) },
{ "KeyPersistAsync", () => db.KeyPersistAsync("key") },
{ "KeyRandomAsync", () => db.KeyRandomAsync() },
{ "KeyRenameAsync", () => db.KeyRenameAsync("key1", "key2") },
{ "KeyRestoreAsync", () => db.KeyRestoreAsync("key", new byte[] { 0, 1, 2, 3, 4 }) },
{ "KeyTimeToLiveAsync", () => db.KeyTimeToLiveAsync("key") },
{ "KeyTypeAsync", () => db.KeyTypeAsync("key") },
{ "ListGetByIndexAsync", () => db.ListGetByIndexAsync("listkey", 0) },
{ "ListInsertAfterAsync", () => db.ListInsertAfterAsync("listkey", "value1", "value2") },
{ "ListInsertBeforeAsync", () => db.ListInsertBeforeAsync("listkey", "value1", "value2") },
{ "ListLeftPopAsync", () => db.ListLeftPopAsync("listkey") },
{ "ListLeftPushAsync", () => db.ListLeftPushAsync("listkey", new RedisValue[] { "value3", "value4" }) },
{ "ListLengthAsync", () => db.ListLengthAsync("listkey") },
{ "ListRangeAsync", () => db.ListRangeAsync("listkey") },
{ "ListRemoveAsync", () => db.ListRemoveAsync("listkey", "value3") },
{ "ListRightPopAsync", () => db.ListRightPopAsync("listkey") },
{ "ListRightPopLeftPushAsync", () => db.ListRightPopLeftPushAsync("listkey", "listkey2") },
{ "ListRightPushAsync", () => db.ListRightPushAsync("listkey", new RedisValue[] { "value5", "value6" }) },
{ "ListSetByIndexAsync", () => db.ListSetByIndexAsync("listkey", 0, "value7") },
{ "ListTrimAsync", () => db.ListTrimAsync("listkey", 0, 1) },
{ "LockExtendAsync", () => db.LockExtendAsync("listkey", "value7", new TimeSpan(0, 0, 10)) },
{ "LockQueryAsync", () => db.LockQueryAsync("listkey") },
{ "LockReleaseAsync", () => db.LockReleaseAsync("listkey", "value7") },
{ "LockTakeAsync", () => db.LockTakeAsync("listkey", "value8", new TimeSpan(0, 0, 10)) },
{ "PublishAsync", () => db.PublishAsync(new RedisChannel("channel", RedisChannel.PatternMode.Auto), "somemessage") },
// { "ScriptEvaluateAsync", () => db.ScriptEvaluateAsync(}
{ "SetAddAsync", () => db.SetAddAsync("setkey", "value1") },
{ "SetCombineAndStoreAsync", () => db.SetCombineAndStoreAsync(SetOperation.Union, "setkey", new RedisKey[] { "value2" }) },
{ "SetCombineAsync", () => db.SetCombineAsync(SetOperation.Union, new RedisKey[] { "setkey1", "setkey2" }) },
{ "SetContainsAsync", () => db.SetContainsAsync("setkey", "value1") },
{ "SetLengthAsync", () => db.SetLengthAsync("setkey") },
{ "SetMembersAsync", () => db.SetMembersAsync("setkey") },
{ "SetMoveAsync", () => db.SetMoveAsync("setkey1", "setkey2", "value2") },
{ "SetPopAsync", () => db.SetPopAsync("setkey1") },
{ "SetRandomMemberAsync", () => db.SetRandomMemberAsync("setkey") },
{ "SetRandomMembersAsync", () => db.SetRandomMembersAsync("setkey", 2) },
{ "SetRemoveAsync", () => db.SetRemoveAsync("setkey", "value2") },
{ "SortAndStoreAsync", () => db.SortAndStoreAsync("setkey2", "setkey") },
{ "SortAsync", () => db.SortAsync("setkey") },
{ "SortedSetAddAsync", () => db.SortedSetAddAsync("ssetkey", new SortedSetEntry[] { new SortedSetEntry("value1", 1.5), new SortedSetEntry("value2", 2.5) }) },
{ "SortedSetCombineAndStoreAsync", () => db.SortedSetCombineAndStoreAsync(SetOperation.Union, "ssetkey1", "ssetkey2", "ssetkey3") },
{ "SortedSetDecrementAsync", () => db.SortedSetDecrementAsync("ssetkey", "value1", 1) },
{ "SortedSetIncrementAsync", () => db.SortedSetIncrementAsync("ssetkey", "value2", 1) },
{ "SortedSetLengthAsync", () => db.SortedSetLengthAsync("ssetkey") },
{ "SortedSetLengthByValueAsync", () => db.SortedSetLengthByValueAsync("ssetkey", "value1", "value2") },
{ "SortedSetRangeByRankAsync", () => db.SortedSetRangeByRankAsync("ssetkey") },
{ "SortedSetRangeByRankWithScoresAsync", () => db.SortedSetRangeByRankWithScoresAsync("ssetkey") },
{ "SortedSetRangeByScoreAsync", () => db.SortedSetRangeByScoreAsync("ssetkey") },
{ "SortedSetRangeByScoreWithScoresAsync", () => db.SortedSetRangeByScoreWithScoresAsync("ssetkey") },
{ "SortedSetRangeByValueAsync", () => db.SortedSetRangeByValueAsync("ssetkey") },
{ "SortedSetRankAsync", () => db.SortedSetRankAsync("ssetkey", "value1") },
{ "SortedSetRemoveAsync", () => db.SortedSetRemoveAsync("ssetkey", "value1") },
{ "SortedSetRemoveRangeByRankAsync", () => db.SortedSetRemoveRangeByRankAsync("ssetkey", 0, 1) },
{ "SortedSetRemoveRangeByScoreAsync", () => db.SortedSetRemoveRangeByScoreAsync("ssetkey", 0, 1) },
{ "SortedSetRemoveRangeByValueAsync", () => db.SortedSetRemoveRangeByValueAsync("ssetkey", "value1", "value2") },
{ "SortedSetScoreAsync", () => db.SortedSetScoreAsync("ssestkey", "value1") },
{ "StringAppendAsync", () => db.StringAppendAsync("ssetkey", "value1") },
{ "StringBitCountAsync", () => db.StringBitCountAsync("ssetkey") },
{ "StringBitOperationAsync", () => db.StringBitOperationAsync(Bitwise.And, "ssetkey1", new RedisKey[] { "ssetkey2", "ssetkey3" }) },
{ "StringBitPositionAsync", () => db.StringBitPositionAsync("ssetkey1", true) },
{ "StringDecrementAsync", () => db.StringDecrementAsync("key", 1.45) },
{ "StringGetAsync", () => db.StringGetAsync("key") },
{ "StringGetBitAsync", () => db.StringGetBitAsync("key", 3) },
{ "StringGetRangeAsync", () => db.StringGetRangeAsync("key", 0, 1) },
{ "StringGetSetAsync", () => db.StringGetSetAsync("key", "value") },
{ "StringGetWithExpiryAsync", () => db.StringGetWithExpiryAsync("key") },
{ "StringIncrementAsync", () => db.StringIncrementAsync("key", 1) },
{ "StringLengthAsync", () => db.StringLengthAsync("key") },
{ "StringSetAsync", () => db.StringSetAsync(new KeyValuePair <RedisKey, RedisValue>[] { new KeyValuePair <RedisKey, RedisValue>("key", "value") }) },
{ "StringSetBitAsync", () => db.StringSetBitAsync("key", 0, true) },
{ "StringSetRangeAsync", () => db.StringSetRangeAsync("key", 3, "value") },
};
var pending = new TupleList <string, Task>();
foreach (var item in tasks)
{
try
{
pending.Add(item.Item1, item.Item2());
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
Console.WriteLine($"{e.Message}");
}
}
return(pending);
}