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);
}
