/// <summary>Initializes a new instance of the <see cref="ReviewCollectionDue" /> class.</summary> /// <param name="db">Database instance.</param> /// <param name="dueCardsLeft">Due card count for currenet session.</param> public ReviewCollectionDue(IDatabaseAsync db, int dueCardsLeft) : base(db) { DueCardsLeft = dueCardsLeft; Comparer = ReviewComparers.DueComparer; Initialize(true); }
public RedisMessageTracker(ChatRoom chatRoom, IDatabaseAsync database, int historyLength = 50) { this.chatRoom = chatRoom; this.database = database; this.historyLength = historyLength; this.chatKey = $"chatRoom:messageHistory:{chatRoom.Id}"; }
// $"{_indexCollectionPrefix}[{indexedKey}]"; public async Task <TIndexedValue[]> GetAsync(IDatabaseAsync context, string indexedKey) { var setKey = GenerateSetName(indexedKey); var jsonValues = await context.SetMembersAsync(setKey); return(jsonValues.Select(jsonValue => _indexedValueReader(jsonValue)).ToArray()); }
public IObservable <IDataKey> GetKeys(IDatabaseAsync database, IIndexKey indexes, long start = 0, long stop = -1) { log.LogTrace("GetKeys"); var keys = GetIds(database, indexes, start, stop); return(keys.Select(item => GetKey(item, indexes))); }
public Worker(ILogger <Worker> logger, MysqlDataAccessSingleton mysqlDataAccess, ConnectionMultiplexer connectionMultiplexer, EtriCommandPublisher publisher) { _logger = logger; this.mysqlDataAccess = mysqlDataAccess; redisdatabaseAsync = connectionMultiplexer.GetDatabase(1); this.publisher = publisher; }
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 RedisClient(ILogger <RedisClient> logger, IRedisLink link, IMainIndexManager mainIndexManager, IDatabaseAsync database = null) { this.link = link ?? throw new ArgumentNullException(nameof(link)); this.mainIndexManager = mainIndexManager ?? throw new ArgumentNullException(nameof(mainIndexManager)); this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.database = database; }
/// <summary> /// Computes the session card review count values asynchronously. /// </summary> /// <param name="db">Database instance.</param> /// <param name="config">The configuration.</param> /// <returns></returns> public static async Task <ReviewSession> ComputeSessionAsync( IDatabaseAsync db, CollectionConfig config) { int todayStart = DateTime.Today.ToUnixTimestamp(); int todayEnd = DateTimeExtensions.Tomorrow.ToUnixTimestamp(); IEnumerable <ReviewLog> logs = await db.Table <ReviewLog>() .Where( l => l.Id >= todayStart && l.Id < todayEnd && (l.LastState == PracticeState.New || l.LastState == PracticeState.Due)) .SelectColumns(nameof(ReviewLog.LastState)) .ToListAsync() .ConfigureAwait(false); int newReviewedToday = logs.Count(l => l.LastState == PracticeState.New); int dueReviewedToday = logs.Count() - newReviewedToday; int newCount = config.NewCardPerDay - newReviewedToday; int dueCount = config.DueCardPerDay - dueReviewedToday; return(new ReviewSession(newCount, dueCount)); }
private void BeginConnection() { var config = new ConfigurationOptions() { ClientName = "HeroBot_v2_runtime", Password = _config.GetSection("redis").GetSection("auth").GetSection("password").Value, DefaultDatabase = int.Parse(_config.GetSection("redis").GetSection("database").Value) }; config.EndPoints.Add($"{_config.GetSection("redis").GetSection("host").Value}:{_config.GetSection("redis").GetSection("port").Value}"); var redis = ConnectionMultiplexer.Connect(config); redis.ConnectionFailed += (sender, evcent) => { _loggingService.Log(Discord.LogSeverity.Error, "Can't connect to Redis host"); }; redis.ConnectionRestored += (sender, evcent) => { _loggingService.Log(Discord.LogSeverity.Warning, "Reconnected to the redis cluster"); }; _subscriber = redis.GetSubscriber(); _loggingService.Log(Discord.LogSeverity.Info, "Connected to redis pub/sub !"); _database = redis.GetDatabase(int.Parse(_config.GetSection("redis")["database"]), new object { }); _loggingService.Log(Discord.LogSeverity.Info, "Connected to redis database !"); }
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)); }
public Task SaveItems(IDatabaseAsync database, IDataKey key, params RedisValue[] redisValues) { var redisKey = link.GetKey(key); logger.LogTrace("SaveItems: <{0}>", key); var tasks = new List <Task>(mainIndexManager.Add(database, key)); var size = GetLimit(key); if (size.HasValue) { var list = redisValues.ToList(); list.Add(size.Value); tasks.Add(database.ScriptEvaluateAsync( link.Generator.GenerateInsertScript(true, redisValues.Length), new[] { redisKey }, list.ToArray())); } else { tasks.Add(database.ListRightPushAsync(redisKey, redisValues)); } return(Task.WhenAll(tasks)); }
public async Task <bool> DeleteAsync(IDatabaseAsync redisDatabase, TKey key) { var headerKey = _keygen.GetKey(key); var chunkDeletes = new List <Task <bool> >(); using (var redisLock = _lockFactory.GetLockInstance(headerKey)) { await redisLock.AcquireAsync().ConfigureAwait(false); var header = await redisDatabase.StringGetAsync(headerKey).ConfigureAwait(false); if (header.IsNullOrEmpty) { return(false); } var chunkCount = (int)header; for (var chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++) { var chunkKey = _keygen.GetKey(key, chunkIndex.ToString()); chunkDeletes.Add(redisDatabase.KeyDeleteAsync(chunkKey)); } await Task.WhenAll(chunkDeletes).ConfigureAwait(false); return(await redisDatabase.KeyDeleteAsync(headerKey).ConfigureAwait(false)); } }
private Task <bool> WriteToRedisAsync(IDatabaseAsync redisDatabase, TKey key, TimeSpan?expiry, string bufferContent, int chunkIndex) { return(redisDatabase.StringSetAsync( _keygen.GetKey(key, chunkIndex.ToString()), bufferContent, expiry)); }
public IObservable <T> GetRecords(IDatabaseAsync database, IDataKey dataKey, long fromRecord = 0, long toRecord = -1) { if (database == null) { throw new ArgumentNullException(nameof(database)); } if (dataKey == null) { throw new ArgumentNullException(nameof(dataKey)); } var key = link.GetKey(dataKey); return(Observable.Create <T>( async observer => { var items = await link.Resilience.AsyncRetryPolicy.ExecuteAsync(async() => await redisSetList.GetRedisValues(database, key, fromRecord, toRecord).ConfigureAwait(false)) .ConfigureAwait(false); var values = GetValues(key, items); foreach (var value in values) { observer.OnNext(value); } observer.OnCompleted(); })); }
private static async Task SetAsync(IDatabaseAsync cache, string key, object value, double expirationTimeInMinutes) { await cache.StringSetAsync(key, Serialize(value)).ConfigureAwait(false); // We will default to a five minute expiration await cache.KeyExpireAsync(key, TimeSpan.FromMinutes(expirationTimeInMinutes)).ConfigureAwait(false); }
public async Task <TItem> ReadAsync(IDatabaseAsync redisDatabase, TKey key, TimeSpan?resetExpiry) { var headerKey = _keygen.GetKey(key); var chunkGets = new List <Task <RedisValue> >(); using (var redisLock = _lockFactory.GetLockInstance(headerKey)) { await redisLock.AcquireAsync().ConfigureAwait(false); var header = await GetAndUpdateExpiry(redisDatabase, headerKey, resetExpiry).ConfigureAwait(false); if (header.IsNullOrEmpty) { return(default(TItem)); } var totalChunks = (int)header; for (var chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) { var chunkKey = _keygen.GetKey(key, chunkIndex.ToString()); chunkGets.Add(GetAndUpdateExpiry(redisDatabase, chunkKey, resetExpiry)); } await Task.WhenAll(chunkGets).ConfigureAwait(false); } var jsonData = string.Join("", chunkGets.Select(cg => cg.Result)); return(string.IsNullOrEmpty(jsonData) ? default(TItem) : JsonConvert.DeserializeObject <TItem>(jsonData)); }
public IObservable <T> GetRecords(IDatabaseAsync database, IDataKey dataKey, long fromRecord = 0, long toRecord = -1) { if (database == null) { throw new ArgumentNullException(nameof(database)); } if (dataKey == null) { throw new ArgumentNullException(nameof(dataKey)); } if (typeof(T) != typeof(SortedSetEntry)) { throw new ArgumentOutOfRangeException(nameof(T)); } var key = link.GetKey(dataKey); return(Observable.Create <T>( async observer => { var items = await link.Resilience.AsyncRetryPolicy.ExecuteAsync( async() => await database.SortedSetRangeByScoreWithScoresAsync(key, skip: fromRecord, take: toRecord) .ConfigureAwait(false)) .ConfigureAwait(false); foreach (var value in items) { observer.OnNext((T)(object)value); } observer.OnCompleted(); })); }
public Task Close() { _connection.Dispose(); _connection = null; _db = null; return(Task.CompletedTask); }
// readonly UdpClient udpClient = new UdpClient(10000); public Worker(ILogger <Worker> logger, IRedisDataAccessor _redis, IPacketQueue queue) { _logger = logger; logger.LogInformation("entry worker"); redisDataAccessor = _redis; db = _redis.Connection().GetDatabase(); packetQueue = queue; }
public Task DeleteAll(IDatabaseAsync database, IDataKey key) { log.LogDebug("DeleteAll: [{0}]", key); var tasks = new List <Task>(mainIndexManager.Delete(database, key)); tasks.Add(link.DeleteAll(database, key)); return(Task.WhenAll(tasks)); }
/// <summary> /// `JSON.STRLEN` /// /// Report the length of the JSON String at `path` in `key`. /// /// `path` defaults to root if not provided. If the `key` or `path` do not exist, null is returned. /// /// https://oss.redislabs.com/rejson/commands/#jsonstrlen /// </summary> /// <param name="db"></param> /// <param name="key">The key of the JSON object you need string length information about.</param> /// <param name="path">The path of the JSON string you want the length of. This defaults to root.</param> /// <param name="commandFlags">Optional command flags.</param> /// <returns>Integer, specifically the string's length.</returns> public static async Task <int?[]> JsonStringLengthAsync(this IDatabaseAsync db, RedisKey key, string path = ".", CommandFlags commandFlags = CommandFlags.None) { var result = await db.ExecuteAsync(JsonCommands.STRLEN, CombineArguments(key, path), flags : commandFlags) .ConfigureAwait(false); return(NullableIntArrayFrom(result)); }
public override void Remove(IDatabaseAsync context, IEnumerable <TValue> items) { foreach (var item in items) { context.SetRemoveAsync(GenerateSetName(IndexedKeyExtractor.ExtractKey(item)), IndexedValueExtractor(item)); } }
/// <summary> /// `JSON.TOGGLE` /// /// Toggle the boolean property of a JSON object. /// /// Official documentation forthcoming. /// </summary> /// <param name="db"></param> /// <param name="key">The key of the JSON object that contains the property that you'd like to toggle.</param> /// <param name="path">The path to the boolean property on JSON object that you'd like to toggle.</param> /// <param name="commandFlags">Optional command flags.</param> /// <returns></returns> public static async Task <bool> JsonToggleAsync(this IDatabaseAsync db, RedisKey key, string path, CommandFlags commandFlags = CommandFlags.None) { var result = await db.ExecuteAsync(JsonCommands.TOGGLE, new object[] { key, path }, flags : commandFlags) .ConfigureAwait(false); return(bool.Parse(result.ToString())); }
/// <summary>Initializes a new instance of the <see cref="ReviewCollectionNew" /> class.</summary> /// <param name="db">Database instance</param> /// <param name="config">Current session collection configuration</param> /// <param name="newCardsLeft">New cards count for current session</param> public ReviewCollectionNew(IDatabaseAsync db, CollectionConfig config, int newCardsLeft) : base(db) { NewCardsLeft = newCardsLeft; Random = config.InsertionOption == CardOrderingOption.Random; Initialize(true); }
public DistributedCancellationProcessor(ILockFactory lockFactory, ILogger logger, ISubscriber redisSubscriber, DistributedCancellationConfiguration distributedCancellationConfiguration, IDatabaseAsync databaseAsync) { _lockFactory = lockFactory; _logger = logger; _redisSubscriber = redisSubscriber; _distributedCancellationConfiguration = distributedCancellationConfiguration; _databaseAsync = databaseAsync; }
public EventStore(string connectionString, string dbname) { Guard.AgainstNullArgument(nameof(connectionString), connectionString); Guard.AgainstNullArgument(nameof(dbname), dbname); _db = ConnectionMultiplexer.Connect(connectionString).GetDatabase(); _dbname = dbname; }
/// <summary> /// `JSON.CLEAR` /// /// Clear/empty arrays and objects (to have zero slots/keys without deleting the array/object) returning the count /// of cleared paths (ignoring non-array and non-objects paths). /// /// Official documentation forthcoming. /// </summary> /// <param name="db"></param> /// <param name="key"></param> /// <param name="path"></param> /// <param name="commandFlags">Optional command flags.</param> /// <returns></returns> public static async Task <int> JsonClearAsync(this IDatabaseAsync db, RedisKey key, string path, CommandFlags commandFlags = CommandFlags.None) { var result = await db.ExecuteAsync(JsonCommands.CLEAR, new object[] { key, path }, flags : commandFlags) .ConfigureAwait(false); return((int)result); }
/// <summary> /// Evaluates this LoadedLuaScript against the given database, extracting parameters for the passed in object if any. /// /// This method sends the SHA1 hash of the ExecutableScript instead of the script itself. If the script has not /// been loaded into the passed Redis instance it will fail. /// </summary> public Task <RedisResult> EvaluateAsync(IDatabaseAsync db, object ps = null, RedisKey?withKeyPrefix = null, CommandFlags flags = CommandFlags.None) { RedisKey[] keys; RedisValue[] args; Original.ExtractParameters(ps, withKeyPrefix, out keys, out args); return(db.ScriptEvaluateAsync(Hash, keys, args, flags)); }
public async static Task <ThrottleResult> ThrottleAsync( this IDatabaseAsync db, RedisKey key, int maxBurst, int maxPerInterval, int intervalSeconds = 60, int count = 1) { return(new ThrottleResult(await db.ExecuteAsync("CL.THROTTLE", key, maxBurst.Boxed(), maxPerInterval.Boxed(), intervalSeconds.Boxed(), count.Boxed()))); }
public EventSubscribeWorker(ISessionFactory sessionFactory, ConnectionMultiplexer redisConnection) { this.sessionFactory = sessionFactory; this.redisConnection = redisConnection; redisDb = this.redisConnection.GetDatabase(1); Publisher = new EventPublisherWorker(); Publisher.Initialize(); }
public async Task Init(Logger logger, IProviderConfiguration config, string providerName, int numQueues) { _logger = logger; _redisListBaseName = $"orleans-{providerName}-queue"; ReadRedisConnectionParams(config); _connection = await ConnectionMultiplexer.ConnectAsync(_server); _database = _connection.GetDatabase(_databaseNum); logger.AutoInfo($"connection to Redis successful."); IsInitialised = true; }
/// <summary> /// Evaluates this LoadedLuaScript against the given database, extracting parameters for the passed in object if any. /// /// This method sends the SHA1 hash of the ExecutableScript instead of the script itself. If the script has not /// been loaded into the passed Redis instance it will fail. /// </summary> public Task<RedisResult> EvaluateAsync(IDatabaseAsync db, object ps = null, RedisKey? withKeyPrefix = null, CommandFlags flags = CommandFlags.None) { RedisKey[] keys; RedisValue[] args; Original.ExtractParameters(ps, withKeyPrefix, out keys, out args); return db.ScriptEvaluateAsync(Hash, keys, args, flags); }
private Task<bool> Clear(IDatabaseAsync database, Feature feature) { return database.KeyDeleteAsync(feature.Key); }
public Publisher(IDatabaseAsync db, ISubscriber subscriber) { _db = db; _req = new SubscriptionObservableFactory(subscriber); }