private bool ProcessRedisLine(bool async, AsyncSocketEventArgs args)
{
var lineValue = _lineBuffer.ToString();
if (args.HasError)
{
return(ProcessRedisResponse(async, args));
}
if (_firstChar.IsErrorReply())
{
_redisResponse = RedisResponse.CreateError(lineValue, _serializer);
}
else if (_firstChar.IsStatusReply())
{
_redisResponse = RedisResponse.CreateStatus(lineValue, _serializer);
}
else if (_firstChar.IsIntReply())
{
_redisResponse = RedisResponse.CreateInteger(lineValue.ToInt(), _serializer);
}
else if (_firstChar.IsBulkReply())
{
var length = lineValue.ToInt();
//check nil reply
if (length < 0)
{
_redisResponse = RedisResponse.CreateBulk(null, _serializer);
}
else if (length == 0)
{
_redisResponse = RedisResponse.CreateBulk(new byte[0], _serializer);
}
else
{
args.Completed = ProcessRedisBulkLine;
return(ReadBlockLine(length, args) || ProcessRedisBulkLine(async, args));
}
}
else if (_firstChar.IsMultiBulkReply())
{
_multiBulkPartsLeft = lineValue.ToInt();
if (_multiBulkPartsLeft == -1) // multi-bulk nill
{
_redisResponse = RedisResponse.CreateMultiBulk(null, _serializer);
}
else
{
_multiBulkParts = new RedisResponse[_multiBulkPartsLeft];
if (_multiBulkPartsLeft > 0)
{
return(ReadResponseFromStream(async, args));
}
}
}
return(ProcessRedisResponse(async, args));
}
private static void OutResult(RedisResponse result)
{
if (result.ResponseType == ResponseType.Error)
{
Console.WriteLine(result.AsError());
}
else if (result.ResponseType == ResponseType.Status)
{
Console.WriteLine(result.AsStatus());
}
else if (result.ResponseType == ResponseType.Integer)
{
Console.WriteLine(result.AsInteger());
}
else if (result.ResponseType == ResponseType.Bulk)
{
Console.WriteLine(result.AsBulk().As <string>());
}
else if (result.ResponseType == ResponseType.MultiBulk)
{
var mb = result.AsMultiBulk();
foreach (var r in mb)
{
Console.WriteLine(r.As <string>());
}
}
}
public void ExecuteCommand_ReturnsValidResult()
{
var req = new[] { new byte[] { 1 } };
var p = CreatePipeline();
RedisResponse res = null;
p.ExecuteCommandAsync(req, (e, r) => { res = r; });
Assert.AreEqual(_response, res);
}
private bool ProcessRedisBulkLine(bool async, AsyncSocketEventArgs args)
{
if (args.HasError)
{
return(ProcessRedisResponse(async, args));
}
_redisResponse = RedisResponse.CreateBulk(_block, _serializer);
return(ProcessRedisResponse(async, args));
}
public bool Receive(ReceiverAsyncEventArgs args)
{
_curEventArgs = args;
args.Error = null;
args.Response = null;
_multiBulkPartsLeft = 0;
_multiBulkParts = null;
_redisResponse = null;
return(ReadResponseFromStream(false, _socketArgs));
}
private static void OutResult(RedisResponse result)
{
if (result.ResponseType == ResponseType.Error)
Console.WriteLine(result.AsError());
else if (result.ResponseType == ResponseType.Status)
Console.WriteLine(result.AsStatus());
else if (result.ResponseType == ResponseType.Integer)
Console.WriteLine(result.AsInteger());
else if (result.ResponseType == ResponseType.Bulk)
Console.WriteLine(result.AsBulk().As<string>());
else if (result.ResponseType == ResponseType.MultiBulk)
{
var mb = result.AsMultiBulk();
foreach (var r in mb)
{
Console.WriteLine(r.As<string>());
}
}
}
private bool ProcessRedisResponse(bool async, AsyncSocketEventArgs args)
{
if (args.HasError || _multiBulkParts == null)
{
return(CallOperationCompleted(async, args));
}
if (_multiBulkPartsLeft > 0)
{
_multiBulkParts[_multiBulkParts.Length - _multiBulkPartsLeft] = _redisResponse;
}
--_multiBulkPartsLeft;
if (_multiBulkPartsLeft > 0)
{
return(ReadResponseFromStream(async, args));
}
_redisResponse = RedisResponse.CreateMultiBulk(_multiBulkParts, _serializer);
return(CallOperationCompleted(async, args));
}
public RedisPipelineTests()
{
_response = RedisResponse.CreateStatus("OK", null);
_redisSender = new Mock <IRedisSender>();
_redisSender.Setup(c => c.BytesInBuffer).Returns(0);
_redisSender.Setup(c => c.Send(It.IsAny <SenderAsyncEventArgs>()))
.Callback((SenderAsyncEventArgs args) => args.Completed(args)).Returns(true);
_redisSender.Setup(c => c.Flush(It.IsAny <SenderAsyncEventArgs>()))
.Callback((SenderAsyncEventArgs args) =>
{
args.Completed(args);
}).Returns(true);
_redisReceiver = new Mock <IRedisReceiver>();
_redisReceiver.Setup(c => c.Receive(It.IsAny <ReceiverAsyncEventArgs>()))
.Callback((ReceiverAsyncEventArgs args) =>
{
args.Response = _response;
args.Completed(args);
}).Returns(true);
}
internal ChannelMessage(ChannelMessageType messageType, RedisResponse value, params string[] channels)
{
MessageType = messageType;
Value = value;
Channels = channels;
}
private bool ProcessRedisBulkLine(bool async, AsyncSocketEventArgs args)
{
if (args.HasError)
return ProcessRedisResponse(async, args);
_redisResponse = RedisResponse.CreateBulk(_block, _serializer);
return ProcessRedisResponse(async, args);
}
private bool ProcessRedisLine(bool async, AsyncSocketEventArgs args)
{
var lineValue = _lineBuffer.ToString();
if (args.HasError)
return ProcessRedisResponse(async, args);
if (_firstChar.IsErrorReply())
_redisResponse = RedisResponse.CreateError(lineValue, _serializer);
else if (_firstChar.IsStatusReply())
_redisResponse = RedisResponse.CreateStatus(lineValue, _serializer);
else if (_firstChar.IsIntReply())
_redisResponse = RedisResponse.CreateInteger(lineValue.ToInt(), _serializer);
else if (_firstChar.IsBulkReply())
{
var length = lineValue.ToInt();
//check nil reply
if (length < 0)
_redisResponse = RedisResponse.CreateBulk(null, _serializer);
else
{
args.Completed = ProcessRedisBulkLine;
return ReadBlockLine(length, args) || ProcessRedisBulkLine(async, args);
}
}
else if (_firstChar.IsMultiBulkReply())
{
_multiBulkPartsLeft = lineValue.ToInt();
if (_multiBulkPartsLeft == -1) // multi-bulk nill
_redisResponse = RedisResponse.CreateMultiBulk(null, _serializer);
else
{
_multiBulkParts = new RedisResponse[_multiBulkPartsLeft];
if (_multiBulkPartsLeft > 0)
return ReadResponseFromStream(async, args);
}
}
return ProcessRedisResponse(async, args);
}
private void ProcessRedisResponse(TaskCompletionSource <RedisResponse> tcs, Exception ex, RedisResponse response)
{
if (ex != null)
{
tcs.SetException(ProcessException(ex));
}
else if (response.ResponseType == ResponseType.Error)
{
tcs.SetException(new RedisException(response.AsError()));
}
else
{
tcs.SetResult(response);
}
}
private void ProcessRedisResponse(TaskCompletionSource<RedisResponse> tcs, Exception ex, RedisResponse response)
{
if (ex != null)
tcs.SetException(ProcessException(ex));
else if (response.ResponseType == ResponseType.Error)
tcs.SetException(new RedisException(response.AsError()));
else
tcs.SetResult(response);
}
internal ChannelMessage(ChannelMessageType messageType, RedisResponse value, params string[] channels)
{
MessageType = messageType;
Value = value;
Channels = channels;
}
public void Setup()
{
_response = RedisResponse.CreateStatus("OK", null);
_redisSender = new Mock<IRedisSender>();
_redisSender.Setup(c => c.BytesInBuffer).Returns(0);
_redisSender.Setup(c => c.Send(It.IsAny<SenderAsyncEventArgs>()))
.Callback((SenderAsyncEventArgs args) => args.Completed(args)).Returns(true);
_redisSender.Setup(c => c.Flush(It.IsAny<SenderAsyncEventArgs>()))
.Callback((SenderAsyncEventArgs args) =>
{
args.Completed(args);
}).Returns(true);
_redisReceiver = new Mock<IRedisReceiver>();
_redisReceiver.Setup(c => c.Receive(It.IsAny<ReceiverAsyncEventArgs>()))
.Callback((ReceiverAsyncEventArgs args) =>
{
args.Response = _response;
args.Completed(args);
}).Returns(true);
}
private bool ProcessRedisResponse(bool async, AsyncSocketEventArgs args)
{
if (args.HasError || _multiBulkParts == null)
return CallOperationCompleted(async, args);
if (_multiBulkPartsLeft > 0)
_multiBulkParts[_multiBulkParts.Length - _multiBulkPartsLeft] = _redisResponse;
--_multiBulkPartsLeft;
if (_multiBulkPartsLeft > 0)
return ReadResponseFromStream(async, args);
_redisResponse = RedisResponse.CreateMultiBulk(_multiBulkParts, _serializer);
return CallOperationCompleted(async, args);
}
public bool Receive(ReceiverAsyncEventArgs args)
{
_curEventArgs = args;
args.Error = null;
args.Response = null;
_multiBulkPartsLeft = 0;
_multiBulkParts = null;
_redisResponse = null;
return ReadResponseFromStream(false, _socketArgs);
}
