static void EndPipe(IRedisSocket rds, IEnumerable <PipelineCommand> cmds)
{
var err = new List <PipelineCommand>();
var ms = new MemoryStream();
try
{
var respWriter = new RespHelper.Resp3Writer(ms, rds.Encoding, rds.Protocol);
foreach (var cmd in cmds)
{
respWriter.WriteCommand(cmd.Command);
}
if (rds.IsConnected == false)
{
rds.Connect();
}
ms.Position = 0;
ms.CopyTo(rds.Stream);
foreach (var pc in cmds)
{
pc.RedisResult = rds.Read(pc.IsBytes);
pc.Result = pc.Parse(pc.RedisResult);
if (pc.RedisResult.IsError)
{
err.Add(pc);
}
#if net40
#else
pc.TrySetResult(pc.Result, pc.RedisResult.IsError ? new RedisServerException(pc.RedisResult.SimpleError) : null);
#endif
}
}
finally
{
ms.Close();
ms.Dispose();
}
if (err.Any())
{
var sb = new StringBuilder();
for (var a = 0; a < err.Count; a++)
{
var cmd = err[a].Command;
if (a > 0)
{
sb.Append("\r\n");
}
sb.Append(err[a].RedisResult.SimpleError).Append(" {").Append(cmd.ToString()).Append("}");
}
throw new RedisServerException(sb.ToString());
}
}
public bool Connect()
{
_redisSocket.Connect(_endPoint);
if (_redisSocket.Connected)
{
OnConnected();
}
return(_redisSocket.Connected);
}
public bool Connect(int timeout)
{
_redisSocket.Connect(_endPoint, timeout);
if (_redisSocket.Connected)
{
OnConnected();
}
return(_redisSocket.Connected);
}
public AsyncRedisSocket(IRedisSocket rds)
{
_rds = rds;
_oldReceiveTimeout = _rds.ReceiveTimeout;
_rds.ReceiveTimeout = TimeSpan.Zero;
if (rds.IsConnected == false)
{
rds.Connect();
}
StartRead();
}
static void EndPipe(IRedisSocket rds, IEnumerable <PipelineCommand> cmds)
{
var err = new List <PipelineCommand>();
var ms = new MemoryStream();
try
{
foreach (var cmd in cmds)
{
RespHelper.Write(ms, rds.Encoding, cmd.Command, rds.Protocol);
}
if (rds.IsConnected == false)
{
rds.Connect();
}
ms.Position = 0;
ms.CopyTo(rds.Stream);
foreach (var pc in cmds)
{
pc.Command._redisSocket = rds;
pc.Result = pc.Parse(pc);
if (pc.Command.ReadResult.IsError)
{
err.Add(pc);
}
}
}
finally
{
ms.Close();
ms.Dispose();
rds?.Dispose();
}
if (err.Any())
{
var sb = new StringBuilder();
for (var a = 0; a < err.Count; a++)
{
var cmd = err[a].Command;
if (a > 0)
{
sb.Append("\r\n");
}
sb.Append(cmd.ReadResult.SimpleError).Append(" {").Append(cmd.ToString()).Append("}");
}
throw new RedisException(sb.ToString());
}
}
WriteAsyncInfo WriteInQueue(CommandPacket cmd)
{
var ret = new WriteAsyncInfo {
Command = cmd
};
if (_rds.ClientReply == ClientReplyType.on)
{
ret.TaskCompletionSource = new TaskCompletionSource <RedisResult>();
}
var isnew = false;
lock (_writeAsyncLock)
{
_writeQueue.Enqueue(ret);
if (_isfirst == false)
{
isnew = _isfirst = true;
}
if (_bufferStream == null)
{
_bufferStream = new MemoryStream();
}
new RespHelper.Resp3Writer(_bufferStream, _rds.Encoding, _rds.Protocol).WriteCommand(cmd);
}
if (isnew)
{
//Thread.CurrentThread.Join(TimeSpan.FromTicks(1000));
try
{
if (_rds.IsConnected == false)
{
_rds.Connect();
}
}
catch (Exception ioex)
{
lock (_writeAsyncLock)
{
while (_writeQueue.TryDequeue(out var wq))
{
wq.TaskCompletionSource?.TrySetException(ioex);
}
_bufferStream.Close();
_bufferStream.Dispose();
_bufferStream = null;
}
_rds.ReleaseSocket();
_end(_rds, ioex);
throw ioex;
}
for (var a = 0; a < 100; a++)
{
var cou = _writeQueue.Count;
if (cou > 100)
{
break;
}
}
var localQueue = new Queue <WriteAsyncInfo>();
long localQueueThrowException(Exception exception)
{
long counter = 0;
while (localQueue.Any())
{
var witem = localQueue.Dequeue();
if (exception != null)
{
witem.TaskCompletionSource?.TrySetException(exception);
}
else
{
witem.TaskCompletionSource?.TrySetCanceled();
}
counter = Interlocked.Decrement(ref _writeCounter);
}
return(counter);
}
var iswait = _writeCounter > 1;
if (iswait)
{
Thread.CurrentThread.Join(10);
}
_begin();
while (true)
{
if (_writeQueue.Any() == false)
{
Thread.CurrentThread.Join(10);
continue;
}
lock (_writeAsyncLock)
{
while (_writeQueue.TryDequeue(out var wq))
{
localQueue.Enqueue(wq);
}
_bufferStream.Position = 0;
try
{
_bufferStream.CopyTo(_rds.Stream);
_bufferStream.Close();
_bufferStream.Dispose();
_bufferStream = null;
}
catch (Exception ioex)
{
localQueueThrowException(ioex);
_bufferStream.Close();
_bufferStream.Dispose();
_bufferStream = null;
_rds.ReleaseSocket();
_end(_rds, ioex);
throw ioex;
}
}
long counter = 0;
RedisResult rt = null;
//sb.AppendLine($"{name} 线程{Thread.CurrentThread.ManagedThreadId}：合并读取 {localQueue.Count} 个命令 total:{sw.ElapsedMilliseconds} ms");
while (localQueue.Any())
{
var witem = localQueue.Dequeue();
try
{
rt = _rds.Read(false);
}
catch (Exception ioex)
{
localQueueThrowException(ioex);
_rds.ReleaseSocket();
_end(_rds, ioex);
throw ioex;
}
witem.TaskCompletionSource.TrySetResult(rt);
counter = Interlocked.Decrement(ref _writeCounter);
}
if (counter == 0 && _finish())
{
break;
}
Thread.CurrentThread.Join(1);
//sb.AppendLine($"{name} 线程{Thread.CurrentThread.ManagedThreadId}：等待 1ms + {_writeQueue.Count} total:{sw.ElapsedMilliseconds} ms");
}
//sb.AppendLine($"{name} 线程{Thread.CurrentThread.ManagedThreadId}：退出 total:{sw.ElapsedMilliseconds} ms");
_end(_rds, null);
}
return(ret);
}
