public static Memory <byte>?To(this RedisObject value, IBufferPool <byte> bufferPool)
{
switch (value)
{
case RedisByteString byteValue:
{
var result = bufferPool.RentMemory(byteValue.ByteLength);
byteValue.Value.CopyTo(result);
return(result);
}
case RedisCharString charValue:
{
var result = bufferPool.RentMemory(charValue.ByteLength);
ProtocolHandler.Encoding.GetBytes(charValue.Value, result.Span);
return(result);
}
case RedisNull _:
return(null);
default:
throw new NotImplementedException();
}
}
public async Task Set_WithInvalidNameAndValidStringValue_ShouldThrowException(string itemName, object value)
{
RedisValue redisValue = RedisObject.ToRedisValue(value);
Func <Task> task = async() => await this.hashItem.Set(itemName, redisValue);
await Assert.ThrowsAsync <ArgumentNullException>(task);
}
public async Task Set_WithKeyNameAndValueOfDifferentType_ShouldCreateHashKey(string itemName, object value)
{
RedisValue redisValue = RedisObject.ToRedisValue(value);
await this.hashItem.Set(itemName, redisValue);
var actual = this.hashItem.Get(itemName).Result;
var expected = redisValue;
Assert.True(await this.hashItem.ContainsKey(itemName));
Assert.Equal(expected, actual);
}
private static RedisObject[] CreateArgs(string script, string[] keys, RedisValueObject[] args)
{
var result = new RedisObject[args.Length + keys.Length + 2];
result[0] = script.ToValue();
result[1] = keys.Length.ToValue();
for (var i = 0; i < keys.Length; ++i)
{
result[i + 2] = keys[i].ToValue();
}
args.CopyTo(result, keys.Length + 2);
return(result);
}
public override Dictionary <string, T> GetResult(RedisObject resultObject)
{
var arrayItems = ((RedisArray)resultObject).Items;
var result = new Dictionary <string, T>(arrayItems.Count / 2);
for (var i = 0; i < arrayItems.Count; i += 2)
{
var key = ((RedisValueObject)arrayItems[i]).To <string>();
var value = ((RedisValueObject)arrayItems[i + 1]).To <T>();
result.Add(key, value);
}
return(result);
}
public static T To <T>(this RedisObject value)
{
switch (value)
{
case RedisValueObject valueValue:
return(valueValue.To <T>());
case RedisArray arrayValue:
return(arrayValue.To <T>());
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Logs an error to the database.
/// </summary>
/// <remarks>
/// Use the stored procedure called by this implementation to set a
/// policy on how long errors are kept in the log. The default
/// implementation stores all errors for an indefinite time.
/// </remarks>
public override string Log(Error error)
{
if (error == null)
{
throw new ArgumentNullException("error");
}
string errorXml = ErrorXml.EncodeString(error);
Guid id = Guid.NewGuid();
var connections = new List <string>();
if (this.ConnectionString.Contains(","))
{
foreach (var connection in this.ConnectionString.Split(','))
{
connections.Add(connection);
}
}
var redisManager = connections.Count() == 0 ? new RedisManagerPool(this.ConnectionString) : new RedisManagerPool(connections);
using (var client = redisManager.GetClient())
{
var redis = client.As <RedisObject>();
var redisObject = new RedisObject()
{
AllXml = errorXml,
Application = this.ApplicationName,
ErrorId = id,
Host = error.HostName,
Message = error.Message,
Source = error.Source,
StatusCode = error.StatusCode,
TimeUtc = error.Time.ToUniversalTime(),
Type = error.Type,
User = error.User,
Id = id
};
redis.AddToRecentsList(redisObject);
redis.Store(redisObject);
}
return(id.ToString());
}
public static void Write(PipeWriter writer, RedisObject @object)
{
switch (@object)
{
case RedisNull _:
Write(writer, NullData);
Write(writer, NewLine);
return;
case RedisInteger intObject:
Write(writer, IntPrefix);
WriteScalar(writer, intObject.Value);
Write(writer, NewLine);
return;
case RedisString strObject:
Write(writer, StrLenPrefix);
WriteScalar(writer, strObject.ByteLength);
Write(writer, NewLine);
WriteString(writer, strObject);
Write(writer, NewLine);
return;
case RedisArray arrayObject:
Write(writer, ArrayLenPrefix);
WriteScalar(writer, arrayObject.Items.Count);
Write(writer, NewLine);
foreach (var item in arrayObject.Items)
{
Write(writer, item);
}
return;
default:
throw new ArgumentException($"Unsupported object {@object.GetType()}", nameof(@object));
}
}
private static RedisObject[] PrepareParams(string key, T value, TimeSpan?expiration = null, OptimisticConcurrency concurrency = OptimisticConcurrency.None)
{
var paramCount = 2;
if (expiration != null)
{
paramCount += 2;
}
if (concurrency != OptimisticConcurrency.None)
{
++paramCount;
}
var @params = new RedisObject[paramCount];
@params[0] = key.ToValue();
@params[1] = value.ToValue();
var paramIndex = 2;
if (expiration != null)
{
@params[paramIndex++] = CommandSwitches.PX;
@params[paramIndex++] = ((int)expiration.Value.TotalMilliseconds).ToValue();
}
switch (concurrency)
{
case OptimisticConcurrency.IfNotExists:
@params[paramIndex] = CommandSwitches.NX;
break;
case OptimisticConcurrency.IfExists:
@params[paramIndex] = CommandSwitches.XX;
break;
}
return(@params);
}
public abstract void SetResult(RedisObject protocolResult);
public RedisStat(RedisClient redis, string id)
{
allTime = new RedisObject<double>(redis, id + ":" + MemberInfoGetting.GetMemberName(() => allTime));
last24Hrs = new RedisExpiryCounter(redis, id + ":" + MemberInfoGetting.GetMemberName(() => last24Hrs), new TimeSpan(24, 0, 0));
lastHour = new RedisExpiryCounter(redis, id + ":" + MemberInfoGetting.GetMemberName(() => lastHour), new TimeSpan(1, 0, 0));
}
public RedisStat(RedisClient redis, string id)
{
allTime = new RedisObject <double>(redis, id + ":" + MemberInfoGetting.GetMemberName(() => allTime));
last24Hrs = new RedisExpiryCounter(redis, id + ":" + MemberInfoGetting.GetMemberName(() => last24Hrs), new TimeSpan(24, 0, 0));
lastHour = new RedisExpiryCounter(redis, id + ":" + MemberInfoGetting.GetMemberName(() => lastHour), new TimeSpan(1, 0, 0));
}
public override bool GetResult(RedisObject resultObject) => true;
public void ToRedisValue_WithInvalidValue_ShouldThrowException(object value)
{
Action act = () => RedisObject.ToRedisValue(value);
Assert.Throws <ArgumentNullException>(act);
}
protected override T ExtractResult(RedisObject protocolResult) => _command.GetResult(protocolResult);
protected override Memory <byte>?ExtractResult(RedisObject protocolResult) => protocolResult.To(_bufferPool);
public override bool GetResult(RedisObject resultObject) => resultObject != RedisNull.Value;
