private void CheckNotSame(RedisValue x, RedisValue y) { Assert.IsFalse(Equals(x, y)); Assert.IsFalse(x.Equals(y)); Assert.IsFalse(y.Equals(x)); Assert.IsFalse(x.GetHashCode() == y.GetHashCode()); // well, very unlikely }
protected KeyCommand(string key, params RedisValue[] values) { ValidateKey(key); var vals = new RedisValue[1 + values.Length]; vals[0] = key; if (values.Length > 0) values.CopyTo(vals, 1); SetParameters(vals); }
public RedisLock([NotNull]IDatabase redis, [NotNull]RedisKey key, [NotNull]RedisValue owner, [NotNull]TimeSpan timeOut) { _redis = redis; _key = key; _owner = owner; //The comparison below uses timeOut as a max timeSpan in waiting Lock int i = 0; DateTime lockExpirationTime = DateTime.UtcNow +timeOut; while (DateTime.UtcNow < lockExpirationTime) { if (_redis.LockTake(key, owner, timeOut)) return; //assumes that a second call made by the same owner means an extension request var lockOwner = _redis.LockQuery(key); if (lockOwner.Equals(owner)) { //extends the lock only for the remaining time var ttl = redis.KeyTimeToLive(key) ?? TimeSpan.Zero; var extensionTTL = lockExpirationTime - DateTime.UtcNow; if (extensionTTL > ttl) _redis.LockExtend(key, owner, extensionTTL - ttl); isRoot = false; return; } SleepBackOffMultiplier(i); i++; } throw new TimeoutException(string.Format("Lock on {0} with owner identifier {1} Exceeded timeout of {2}", key, owner.ToString(), timeOut)); }
public object Eval(string script, string[] keyArgs, object[] valueArgs) { RedisKey[] redisKeyArgs = new RedisKey[keyArgs.Length]; RedisValue[] redisValueArgs = new RedisValue[valueArgs.Length]; int i = 0; foreach (string key in keyArgs) { redisKeyArgs[i] = key; i++; } i = 0; foreach (object val in valueArgs) { if (val.GetType() == typeof(byte[])) { // User data is always in bytes redisValueArgs[i] = (byte[])val; } else { // Internal data like session timeout and indexes are stored as strings redisValueArgs[i] = val.ToString(); } i++; } return RetryLogic(() => _connection.ScriptEvaluate(script, redisKeyArgs, redisValueArgs)); }
private static void GetMessageUpdates(RedisChannel channel, RedisValue value) { var vals = value.ToString().Split('|'); if (vals.Length != 3 || vals[0] == InstanceId) return; GlobalHost.ConnectionManager.GetHubContext<ChatHub>().Clients.All.receiveMessage(vals[1], vals[2]); }
public void CanHandleCommands() { RedisServiceFactory.Register<IRedisCommandHandler, TestCommandHandler>(); TestCommandHandler cmdHandler = (TestCommandHandler)RedisServiceFactory.CommandHandlers.First(); bool onExecutingDone = false; bool onExecutedDone = false; RedisKey[] testKeys = new RedisKey[] { "test" }; RedisValue[] testValues = new RedisValue[] { "test value" }; object testResult = (RedisValue)"hello world"; cmdHandler.onExecuting = (command, involvedKeys, involvedValues) => { Assert.AreEqual(RedisCommand.SET, command); Assert.AreEqual(1, testKeys.Intersect(involvedKeys).Count()); Assert.AreEqual(1, testValues.Intersect(involvedValues).Count()); onExecutingDone = true; }; cmdHandler.onExecuted = (RedisCommand command, ref object result, RedisKey[] involvedKeys) => { Assert.AreEqual(RedisCommand.HMSET, command); Assert.AreEqual(1, testKeys.Intersect(involvedKeys).Count()); Assert.AreEqual(testResult, result); onExecutedDone = true; }; RedisServiceFactory.CommandHandlers.ExecuteBeforeHandlers(RedisCommand.SET, new RedisKey[] { "test" }, new RedisValue[] { "test value" }); RedisServiceFactory.CommandHandlers.ExecuteAfterHandlers(RedisCommand.HMSET, new RedisKey[] { "test" }, ref testResult); Assert.IsTrue(onExecutingDone); Assert.IsTrue(onExecutedDone); }
public void ListenForMessage(RedisChannel channel, RedisValue value) { Assert.AreEqual(RedisKey, channel.ToString()); Assert.IsFalse(!value.HasValue || value.IsNullOrEmpty); Assert.AreEqual("INFO test pub/sub message", value.ToString()); ActionRun = true; }
public static bool IsExpiredLockValue(RedisValue lockValue, DateTime currentTime) { if (lockValue.IsEmpty) return false; var timeNow = DateTimeExtensions.UnixTimeNow; return (timeNow >= lockValue); }
public static RedisValue[] ConstructParameters(string name, string dstKey, IEnumerable<string> keys) { if (keys == null) throw new ArgumentNullException("keys"); var count = keys.Count(); if (count == 0) throw new ArgumentException("At least 1 source key must be specified."); bool hasDest = dstKey != null; var parameters = new RedisValue[count + (hasDest ? 2 : 1)]; int i = 1; parameters[0] = name; if (hasDest) { parameters[1] = dstKey; i++; } foreach (var key in keys) { if (key == null) throw new ArgumentNullException("keys", "Null value found for key"); parameters[i++] = key; } return parameters; }
/// <summary> ///This method save one or more values to the Set /// </summary> /// <param name="Key">One key</param> /// <param name="RedisObjectList">A list of objects to the Set</param> /// <returns></returns> public long SaveHash(string Key, List<RedisObject> RedisObjectList) { try { ConnectionMultiplexer Connection = ConnectionMultiplexer.Connect(this.ConnectionString); var DataBase = Connection.GetDatabase(); RedisValue[] RedisValueArray = new RedisValue[RedisObjectList.Count()]; int ValueIndex = 0; foreach (RedisObject RedisObjectFound in RedisObjectList) { RedisValueArray[ValueIndex] = new RedisValue(); RedisValueArray[ValueIndex] = RedisObjectFound.Value; ValueIndex++; } return DataBase.SetAdd(Key, RedisValueArray); } catch (Exception) { throw; } }
private void OnInstanceNotified(RedisChannel channel,RedisValue notification) { try { var list = monitors[channel]; var notify = BahamutAppInstanceNotification.FromJson(notification); switch (notify.NotifyType) { case BahamutAppInstanceNotification.TYPE_INSTANCE_HEART_BEAT: foreach (var monitor in list) { monitor.OnInstanceHeartBeating(notify); } break; case BahamutAppInstanceNotification.TYPE_INSTANCE_OFFLINE: foreach (var monitor in list) { monitor.OnInstanceOffline(notify); } break; case BahamutAppInstanceNotification.TYPE_REGIST_APP_INSTANCE: foreach (var monitor in list) { monitor.OnInstanceRegisted(notify); } break; default: break; } } catch (Exception) { } }
private void CheckSame(RedisValue x, RedisValue y) { Assert.IsTrue(Equals(x, y)); Assert.IsTrue(x.Equals(y)); Assert.IsTrue(y.Equals(x)); Assert.IsTrue(x.GetHashCode() == y.GetHashCode()); }
public async Task<bool> SetAsync(string key, RedisValue value, int expirySeconds) { var conn = _connectionManager.GetConnection(); await conn.GetDatabase(_db).StringSetAsync(key, value, _isRedisExpiryEnabled ? (TimeSpan?)TimeSpan.FromSeconds(expirySeconds) : null).ConfigureAwait(false); return true; }
/// <summary> /// Returns the value associated with field in the hash stored at key. /// </summary> /// <returns> /// the value associated with field, or nil when field is not present in the hash or key does not exist. /// </returns> /// <remarks>http://redis.io/commands/hget</remarks> public static Task<RedisValue> GetString(RedisKey key, RedisValue field) { Task<RedisValue> result = SharedCache.Instance.GetReadConnection(key) .GetDatabase(SharedCache.Instance.Db) .HashGetAsync(key, field); return result; }
/// <summary> /// Removes the specified fields from the hash stored at key. Non-existing fields are ignored. Non-existing keys /// are treated as empty hashes and this command returns 0. /// </summary> /// <param name="key"> /// The key. /// </param> /// <param name="field"> /// The field. /// </param> /// <remarks> /// http://redis.io/commands/hdel /// </remarks> /// <returns> /// The number of fields that were removed. /// </returns> public static bool Delete(RedisKey key, RedisValue field) { bool result = SharedCache.Instance.GetWriteConnection(key) .GetDatabase(SharedCache.Instance.Db) .HashDelete(key, field); return result; }
public object OnRead(RedisValue value) { Guid guid; if (value.IsByteArray()) return new Guid((byte[])value); if (Guid.TryParse(value, out guid)) return guid; throw new ArgumentException("Value is not a Guid"); }
/// <summary> /// Removes the specified fields from the hash stored at key. Non-existing fields are ignored. Non-existing keys /// are treated as empty hashes and this command returns 0. /// </summary> /// <param name="key"> /// The key. /// </param> /// <param name="field"> /// The field. /// </param> /// <remarks> /// http://redis.io/commands/hdel /// </remarks> /// <returns> /// The number of fields that were removed. /// </returns> public static Task<bool> DeleteAsync(RedisKey key, RedisValue field) { Task<bool> result = SharedCache.Instance.GetWriteConnection(key) .GetDatabase(SharedCache.Instance.Db) .HashDeleteAsync(key, field); return result; }
/// <summary> /// If key already exists and is a string, this command appends the value at the end of the string. If key does /// not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case. /// </summary> /// <param name="key"> /// The key. /// </param> /// <param name="value"> /// The value. /// </param> /// <returns> /// the length of the string after the append operation. /// </returns> /// <remarks> /// http://redis.io/commands/append /// </remarks> public static Task<long> AppendAsync(RedisKey key, RedisValue value) { Task<long> result = SharedCache.Instance.GetWriteConnection(key) .GetDatabase(SharedCache.Instance.Db) .StringAppendAsync(key, value); return result; }
public SMoveCommand(String srcKey, String dstKey, RedisValue member) { if (srcKey == null) throw new ArgumentNullException("srcKey"); if (dstKey == null) throw new ArgumentNullException("dstkey"); SetParameters(srcKey, dstKey, member); }
void SubscriberMessageReceived(RedisChannel redisChannel, RedisValue value) { if (!((string)redisChannel).EndsWith("expired")) return; var key = Encoding.UTF8.GetString(value); LogMethod("Expired", key, null); RemoveMethod(key); }
protected void Init(string name, params RedisValue[] parameters) { var vals = new RedisValue[1 + parameters.Length]; vals[0] = name; if (parameters.Length > 0) parameters.CopyTo(vals, 1); _params = vals; }
public PublishCommand(String channelName, RedisValue message) { if (channelName == null) throw new ArgumentNullException("channelName", "Class name must be specified."); if (String.IsNullOrEmpty(channelName)) throw new ArgumentException("Class name must have a value","channelName"); SetParameters(channelName, message); }
protected virtual void CompressAdd(RedisValue[] involvedValues) { for (int i = 0; i < involvedValues.Length; i++) { byte[] valueBlob = involvedValues[i]; RedisValueCompressor.Compressor.Compress(ref valueBlob); involvedValues[i] = valueBlob; } }
public void Append(RedisValue[] commandInfo) { // assumes all are bulk values AppendLengthMeta((byte)'*', commandInfo.Length); foreach (var arg in commandInfo) { WriteBulk(arg); } }
/// <summary> /// Store data to the Cached with a key and value (format byte[]) in durationInMinute(minutes) /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="duration"></param> /// <returns></returns> public bool Set(string key, RedisValue value, TimeSpan? duration = null) { RedisKey redisKey = key; this.GetDatabase().StringSet(redisKey, value, duration); //var connection = ConfigConnection().GetDatabase(1); //connection.StringSet(redisKey, value, timeSpanDuration); return true; }
/// <summary> /// Executes all Redis command handlers, running behaviors that must run before some given command is about to get executed. /// </summary> /// <param name="handlers">The sequence of Redis command handlers</param> /// <param name="command">The Redis command</param> /// <param name="involvedKeys">An array of involved Redis keys in the command</param> /// <param name="involvedValues">An array of involved Redis values in the command</param> /// <returns>True if handlers could be executed. Otherwise, false.</returns> public static bool ExecuteBeforeHandlers(this IEnumerable<IRedisCommandHandler> handlers, RedisCommand command, RedisKey[] involvedKeys = null, RedisValue[] involvedValues = null) { bool canExecute = CanExecuteHandlers(handlers, command); if (canExecute) foreach (IRedisCommandHandler handler in handlers) handler.OnExecuting(command, involvedKeys, involvedValues); return canExecute; }
/// <summary> /// Adds a value to the bloom filter. /// </summary> /// <param name="key"> /// The key. /// </param> /// <param name="value"> /// The value. /// </param> public void Add(string key, string value) { var bits = new RedisValue[this.Options.NumberOfHashes]; for (int i = 0; i < this.Options.NumberOfHashes; i++) { bits[i] = Hashing.Murmur3.ComputeInt(value + i) % this.Options.NumberOfBits; } SetBits(key, bits, true); }
public object OnRead(RedisValue obj) { double value; if (double.TryParse(obj, out value)) { return value; } throw new InvalidCastException("obj is not an double value"); }
private static RedisValue[] GetRedisMembers(params string[] members) { var redisMembers = new RedisValue[members.Length]; for (int i = 0; i < members.Length; i++) { redisMembers[i] = (RedisValue)members[i]; } return redisMembers; }
public object OnRead(RedisValue obj) { int value; if (int.TryParse(obj, out value)) { return value; } throw new InvalidCastException("obj is not an Int32 value"); }
public Task<RedisValue[]> StreamClaimIdsOnlyAsync(RedisKey key, RedisValue consumerGroup, RedisValue claimingConsumer, long minIdleTimeInMs, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) { return Inner.StreamClaimIdsOnlyAsync(ToInner(key), consumerGroup, claimingConsumer, minIdleTimeInMs, messageIds, flags); }
public Task<RedisValue> StringSetRangeAsync(RedisKey key, long offset, RedisValue value, CommandFlags flags = CommandFlags.None) { return Inner.StringSetRangeAsync(ToInner(key), offset, value, flags); }
public Task<bool> StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position = null, CommandFlags flags = CommandFlags.None) { return Inner.StreamCreateConsumerGroupAsync(ToInner(key), groupName, position, flags); }
async Task IAsyncHashSet <TKey, TValue> .AddAsync(TKey key, TValue value) { await Database.HashSetAsync(SetKey, RedisValue.Unbox(key), Serializer.Serialize(value)); }
public Task<long> StreamAcknowledgeAsync(RedisKey key, RedisValue groupName, RedisValue[] messageIds, CommandFlags flags = CommandFlags.None) { return Inner.StreamAcknowledgeAsync(ToInner(key), groupName, messageIds, flags); }
public Task<RedisStream[]> StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, CommandFlags flags = CommandFlags.None) { return Inner.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, flags); }
async Task IAsyncHashSet <TKey, TValue> .AddAsync(params KeyValuePair <TKey, TValue>[] pairs) { var entities = pairs.Select(t => new HashEntry(RedisValue.Unbox(t.Key), Serializer.Serialize(t.Value))) .ToArray(); await Database.HashSetAsync(SetKey, entities); }
public Task<bool> StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, When when = When.Always, CommandFlags flags = CommandFlags.None) { return Inner.StringSetAsync(ToInner(key), value, expiry, when, flags); }
public Task<StreamEntry[]> StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, CommandFlags flags = CommandFlags.None) { return Inner.StreamReadGroupAsync(ToInner(key), groupName, consumerName, position, count, flags); }
public void Add(TKey key, TValue value) { Database.HashSet(SetKey, RedisValue.Unbox(key), Serializer.Serialize(value)); }
public Task <long> HashIncrementAsync(RedisKey key, RedisValue hashField, long value = 1, CommandFlags flags = CommandFlags.None) { return(Inner.HashIncrementAsync(ToInner(key), hashField, value, flags)); }
public Task<double> HashDecrementAsync(RedisKey key, RedisValue hashField, double value, CommandFlags flags = CommandFlags.None) { return Inner.HashDecrementAsync(ToInner(key), hashField, value, flags); }
public Task<StreamPendingMessageInfo[]> StreamPendingMessagesAsync(RedisKey key, RedisValue groupName, int count, RedisValue consumerName, RedisValue? minId = null, RedisValue? maxId = null, CommandFlags flags = CommandFlags.None) { return Inner.StreamPendingMessagesAsync(ToInner(key), groupName, count, consumerName, minId, maxId, flags); }
public Task<RedisValue> StringGetSetAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) { return Inner.StringGetSetAsync(ToInner(key), value, flags); }
Task <bool> IBatchHashSet <TKey, TValue> .BatchRemove(IBatch batch, TKey key) { return(batch.HashDeleteAsync(SetKey, RedisValue.Unbox(key))); }
async Task IAsyncHashSet <TKey, TValue> .AddAsync(params Tuple <TKey, TValue>[] tuples) { var entities = tuples.Select(t => new HashEntry(RedisValue.Unbox(t.Item1), Serializer.Serialize(t.Item2))) .ToArray(); await Database.HashSetAsync(SetKey, entities); }
private void OnStop(RedisChannel ch, RedisValue data) { var shardId = JsonConvert.DeserializeObject <int>(data); OnStop(shardId); }
public Task<RedisValue> HashGetAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) { return Inner.HashGetAsync(ToInner(key), hashField, flags); }
public Task<long> StringAppendAsync(RedisKey key, RedisValue value, CommandFlags flags = CommandFlags.None) { return Inner.StringAppendAsync(ToInner(key), value, flags); }
public Task<StreamConsumerInfo[]> StreamConsumerInfoAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) { return Inner.StreamConsumerInfoAsync(ToInner(key), groupName, flags); }
public Task<RedisValue> StreamAddAsync(RedisKey key, RedisValue streamField, RedisValue streamValue, RedisValue? messageId = null, int? maxLength = null, bool useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None) { return Inner.StreamAddAsync(ToInner(key), streamField, streamValue, messageId, maxLength, useApproximateMaxLength, flags); }
protected RedisValue ToInner(RedisValue outer) { return RedisKey.ConcatenateBytes(Prefix, null, (byte[])outer); }
public Task<StreamPendingInfo> StreamPendingAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) { return Inner.StreamPendingAsync(ToInner(key), groupName, flags); }
public bool Remove(TKey key) { return(Database.HashDelete(SetKey, RedisValue.Unbox(key))); }
public Task<bool> StreamDeleteConsumerGroupAsync(RedisKey key, RedisValue groupName, CommandFlags flags = CommandFlags.None) { return Inner.StreamDeleteConsumerGroupAsync(ToInner(key), groupName, flags); }
public Task<StreamEntry[]> StreamReadAsync(RedisKey key, RedisValue position, int? count = null, CommandFlags flags = CommandFlags.None) { return Inner.StreamReadAsync(ToInner(key), position, count, flags); }
Task IBatchHashSet <TKey, TValue> .BatchAdd(IBatch batch, TKey key, TValue value) { return(batch.HashSetAsync(SetKey, RedisValue.Unbox(key), Serializer.Serialize(value))); }
public T JsonGet <T>(RedisKey key, CommandFlags flags = CommandFlags.None) { RedisValue str = Connection.GetDatabase().StringGet(key, flags); return(str.ToObject <T>()); }
async Task <bool> IAsyncHashSet <TKey, TValue> .RemoveAsync(TKey key) { return(await Database.HashDeleteAsync(SetKey, RedisValue.Unbox(key))); }
public Task<double?> SortedSetScoreAsync(RedisKey key, RedisValue member, CommandFlags flags = CommandFlags.None) { return Inner.SortedSetScoreAsync(ToInner(key), member, flags); }