private bool ReadBlockLineTask(bool async, AsyncSocketEventArgs args)
{
if (args.HasError)
{
return(CallSocketOpCompleted(async, args));
}
while (_readBytes < _block.Length)
{
if (_offset >= _bufferSize)
{
return(ReceiveDataFromSocket(args) || ReadBlockFromSocketCallBack(async, args));
}
var bytesToCopy = _block.Length - _readBytes;
var bytesInBufferLeft = _bufferSize - _offset;
if (bytesToCopy > bytesInBufferLeft)
{
bytesToCopy = bytesInBufferLeft;
}
Array.Copy(_readSocketBuffer, _offset, _block, _readBytes, bytesToCopy);
_readBytes += bytesToCopy;
IncrementOffset(bytesToCopy);
}
IncrementOffset(2);
return(CallSocketOpCompleted(async, args));
}
private bool ReadLineTask(bool async, AsyncSocketEventArgs args)
{
if (args.HasError)
{
return(CallSocketOpCompleted(async, args));
}
while (true)
{
if (_offset >= _bufferSize)
{
return(ReceiveDataFromSocket(args) || ReadLineCallBack(async, args));
}
var dataByte = _readSocketBuffer[_offset];
IncrementOffset(1);
if (dataByte == '\r')
{
IncrementOffset(1);
return(CallSocketOpCompleted(async, args));
}
if (_firstChar == 0)
{
_firstChar = dataByte;
}
else
{
_lineBuffer.Append((char)dataByte);
}
}
}
public void Disconnect_CallsSocketConnect()
{
var args = new AsyncSocketEventArgs();
var sock = CreateSocket();
sock.Disconnect(args);
_socket.Verify(s => s.DisconnectAsync(It.IsAny<SocketAsyncEventArgs>()));
}
private bool ReceiveDataFromSocket(AsyncSocketEventArgs args)
{
try
{
if (_buffersPool.TryGet(out _readSocketBuffer,
b =>
{
_readSocketBuffer = b;
args.BufferToReceive = _readSocketBuffer;
if (!_asyncSocket.Receive(args))
{
args.Completed(args);
}
}))
{
args.BufferToReceive = _readSocketBuffer;
return(_asyncSocket.Receive(args));
}
return(true);
}
catch (Exception ex)
{
args.Error = ex;
return(false);
}
}
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));
}
public RedisReceiver(IBuffersPool buffersPool, IAsyncSocket asyncSocket)
{
_buffersPool = buffersPool;
_asyncSocket = asyncSocket;
_socketArgs = new AsyncSocketEventArgs();
_lineBuffer = new StringBuilder();
_offset = 0;
}
public RedisReceiver(IBuffersPool buffersPool, IAsyncSocket asyncSocket)
{
_buffersPool = buffersPool;
_asyncSocket = asyncSocket;
_socketArgs = new AsyncSocketEventArgs();
_lineBuffer = new StringBuilder();
_offset = 0;
}
public void Disconnect_CallsSocketConnect()
{
var args = new AsyncSocketEventArgs();
var sock = CreateSocket();
sock.Disconnect(args);
_socket.Verify(s => s.DisconnectAsync(It.IsAny <SocketAsyncEventArgs>()));
}
/// <summary>
/// 连接已建立事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
static void Server_ClientConnected(object sender, AsyncSocketEventArgs e)
{
LogHelpr.Info("客户端连接成功" + e._state.ClientSocket.RemoteEndPoint.ToString());
socket = e._state;
timer = new System.Timers.Timer();
timer.Elapsed += Timer_Elapsed;
timer.Interval = 60000000;
timer.Enabled = true;
}
public bool Disconnect(AsyncSocketEventArgs eventArgs)
{
_notIoArgs.UserToken = eventArgs;
eventArgs.Error = null;
var isAsync = _socket.DisconnectAsync(_notIoArgs);
if (!isAsync) NotSendCallBack(false, _notIoArgs);
return isAsync;
}
private bool ReadBlockLine(int length, AsyncSocketEventArgs args)
{
_block = new byte[length];
_readBytes = 0;
args.Error = null;
args.UserToken = args.Completed;
args.Completed = ReadBlockFromSocketCallBack;
args.DataLength = 0;
return(ReadBlockLineTask(false, args));
}
private bool ReceiveDataFromSocket(AsyncSocketEventArgs args)
{
byte[] buffer;
if (_buffersPool.TryGet(out buffer, b => ReceiveDataFromSocket(b, args, true)))
{
return(ReceiveDataFromSocket(buffer, args, false));
}
return(true);
}
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 ReadBlockFromSocketCallBack(bool async, AsyncSocketEventArgs args)
{
args.BufferToReceive = null;
RecalculateBufferSize(args);
if (args.HasError)
{
ReleaseBuffer();
}
return(ReadBlockLineTask(async, args));
}
public void Connect_CallsSocketConnect()
{
var ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"),1234);
var sock = CreateSocket();
var args = new AsyncSocketEventArgs();
args.RemoteEndPoint = ep;
sock.Connect(args);
_socket.Verify(s=>s.ConnectAsync(
It.Is((SocketAsyncEventArgs a)=> a.RemoteEndPoint == ep)));
}
private bool ReadLine(AsyncSocketEventArgs args)
{
_firstChar = 0;
_lineBuffer.Clear();
args.DataLength = 0;
args.UserToken = args.Completed;
args.Completed = ReadLineCallBack;
args.Error = null;
return(ReadLineTask(false, args));
}
private bool CallOperationCompleted(bool async, AsyncSocketEventArgs eventArgs)
{
_curEventArgs.Error = eventArgs.Error;
_curEventArgs.Response = _redisResponse;
if (async)
{
_curEventArgs.Completed(_curEventArgs);
}
return(async);
}
private bool CallSocketOpCompleted(bool async, AsyncSocketEventArgs eventArgs)
{
_curEventArgs.Error = eventArgs.Error;
var callBack = (Action <AsyncSocketEventArgs>)eventArgs.UserToken;
if (async)
{
callBack(eventArgs);
}
return(async);
}
public RedisSender(IBuffersPool buffersPool, IAsyncSocket asyncSocket, bool autoFlush)
{
_buffersPool = buffersPool;
_asyncSocket = asyncSocket;
_autoFlush = autoFlush;
_senderContext = new SenderContext();
_flushArgs = new AsyncSocketEventArgs();
_flushArgs.Completed = FlushCallBack;
_sendingQueue = new ConcurrentQueue <ArraySegment <byte> >();
}
public void Connect_CallsSocketConnect()
{
var ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1234);
var sock = CreateSocket();
var args = new AsyncSocketEventArgs();
args.RemoteEndPoint = ep;
sock.Connect(args);
_socket.Verify(s => s.ConnectAsync(
It.Is((SocketAsyncEventArgs a) => a.RemoteEndPoint == ep)));
}
public RedisSender(IBuffersPool buffersPool, IAsyncSocket asyncSocket, bool autoFlush)
{
_buffersPool = buffersPool;
_asyncSocket = asyncSocket;
_autoFlush = autoFlush;
_senderContext = new SenderContext();
_flushArgs = new AsyncSocketEventArgs();
_flushArgs.Completed = FlushCallBack;
_sendingQueue = new ConcurrentQueue<ArraySegment<byte>>();
}
public void Receive_CallsSocketReceive()
{
const int bufferSize = 111;
var sock = CreateSocket();
var args = new AsyncSocketEventArgs();
args.BufferToReceive = new byte[bufferSize];
sock.Receive(args);
_socket.Verify(s => s.ReceiveAsync(
It.Is((SocketAsyncEventArgs a) => a.Count == bufferSize &&
a.Offset == 0)));
}
public void NotIoAsyncOperation_CompletedCalled()
{
_socket.Setup(s => s.DisconnectAsync(It.IsAny<SocketAsyncEventArgs>()))
.Callback((SocketAsyncEventArgs a) => { CallOnCompleted(a); })
.Returns(true);
var args = new AsyncSocketEventArgs();
var called = false;
args.Completed = (e) => { called = true; };
var sock = CreateSocket();
sock.Disconnect(args);
Assert.IsTrue(called);
}
public void NotIoSyncOperation_CompletedNotCalled()
{
_socket.Setup(s => s.DisconnectAsync(It.IsAny <SocketAsyncEventArgs>())).Returns(false);
var args = new AsyncSocketEventArgs();
var called = false;
args.Completed = (e) => { called = true; };
var sock = CreateSocket();
sock.Disconnect(args);
Assert.IsFalse(called);
}
private void FlushCallBack(bool async, AsyncSocketEventArgs args)
{
var buffers = (List <ArraySegment <byte> >)args.UserToken;
Interlocked.Exchange(ref _socketException, args.Error);
foreach (var buf in buffers)
{
_buffersPool.ReleaseWithoutNotification(buf.Array);
}
if (async)
{
DoFlushing();
}
_buffersPool.NotifyWaiters();
}
private void Broadcaster_DataReceived(object sender, AsyncSocketEventArgs e)
{
LogTool.Log(e.msg);
//switch (e.msg) {
// case Command.EXIT:
// broadcaster.Close(e.state);
// break;
//}
if (e.msg.StartsWith(NetworkCommand.LOGIN) && clientDic.Count <= maxCount)
{
string[] result = e.msg.Split(';');
LogTool.Log("Login……");
int id = int.Parse(result[1].Split(':')[1]);
string userName = result[2].Split(':')[1];
string password = result[3].Split(':')[1];
IPEndPoint remotePoint = e.state.remote;
string remoteAddress = remotePoint.Address.ToString();
if (!clientDic.ContainsKey(remoteAddress))
{
clientDic.Add(remoteAddress, userName);
}
Loom.DispatchToMainThread(() =>
{
if (!studentDic.ContainsKey(userName))
{
//StudentItemView item = CreateStudent(studentCopy);
//item.IPAddress = remoteAddress;
//item.studentState = e.state;
//item.UserName = userName;
//studentDic.Add(userName, item);
}
});
LogTool.Log("客户端:" + userName + "IP:" + remoteAddress);
SaveDataController.CreateUser(id, userName, password);
SaveDataController.SetServerPort(ipAddress, tcpPort);
udpServer.sendMessage(NetworkCommand.ISCONNECTED);
StartServer();
}
}
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));
}
private void Server_DataReceived(object sender, AsyncSocketEventArgs e)
{
if (tcpServer.isRunning)
{
LogTool.Log(e.msg);
string remoteIpAddress = ((IPEndPoint)e.state.ClientSocket.RemoteEndPoint).Address.ToString();
string clientName = clientDic[remoteIpAddress];
switch (e.msg)
{
case NetworkCommand.HEART_BEAT:
List <AsyncSocketState> clientList = new List <AsyncSocketState>(tcpServer.clientDic.Values);
for (int i = 0; i < clientList.Count; i++)
{
if (clientList[i] != null)
{
if (e.state == clientList[i])
{
tcpServer.clientDic[clientList[i].ClientSocket.RemoteEndPoint].isHeartBeated = true;
}
}
}
break;
case NetworkCommand.EXIT:
Loom.DispatchToMainThread(() =>
{
KickByName(clientName);
});
tcpServer.Close(e.state);
break;
default:
LogTool.Log(clientDic[remoteIpAddress] + ":" + e.msg);
break;
}
}
}
private bool ReceiveDataFromSocket(byte[] buffer, AsyncSocketEventArgs args, bool invokeCompletedCallback)
{
_readSocketBuffer = buffer;
args.BufferToReceive = _readSocketBuffer;
try
{
var async = _asyncSocket.Receive(args);
if (!async && invokeCompletedCallback)
{
args.Completed(args);
}
return(async);
}
catch (Exception ex)
{
args.Error = ex;
if (invokeCompletedCallback)
{
args.Completed(args);
}
return(false);
}
}
private void UdpClient_DataReceived(object sender, AsyncSocketEventArgs e)
{
LogTool.Log(e.msg);
if (e.msg == NetworkCommand.ISCONNECTED)
{
serverPoint = new IPEndPoint(e.state.remote.Address, serverTcpPort);
LogTool.Log(serverPoint);
isConnected = true;
startTCP();
SaveDataController.CreateUser(id, userName, password);
SaveDataController.SetServerPort(serverPoint.Address.ToString(), serverTcpPort);
//closeUDP();
}
else if (e.msg.StartsWith(NetworkCommand.CONNECT) && !isConnected)
{
serverTcpPort = int.Parse(e.msg.Split(':')[1]);
udpClient.AsynSend(NetworkCommand.LOGIN + ";id:" + id + ";userName:"******";psd:" + password);//连接中，发送用户名密码
}
else if (e.msg == NetworkCommand.EXIT)
{
CloseClient();
LogTool.Log("被服务器踢出");
}
}
private void ReadBlockFromSocketCallBack(AsyncSocketEventArgs args)
{
ReadBlockFromSocketCallBack(true, 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 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);
}
private void RecalculateBufferSize(AsyncSocketEventArgs args)
{
_offset = _offset - _bufferSize;
_bufferSize = args.DataLength;
}
private bool ReadResponseFromStream(bool async, AsyncSocketEventArgs args)
{
args.Completed = ProcessRedisLine;
return ReadLine(args) || ProcessRedisLine(async, args);
}
public bool Receive(AsyncSocketEventArgs eventArgs)
{
_receiveArgs.SetBuffer(eventArgs.BufferToReceive, 0,eventArgs.BufferToReceive.Length);
_receiveArgs.UserToken = eventArgs;
eventArgs.Error = null;
var isAsync = _socket.ReceiveAsync(_receiveArgs);
if (!isAsync) NotSendCallBack(false, _receiveArgs);
return isAsync;
}
private bool CallSocketOpCompleted(bool async, AsyncSocketEventArgs eventArgs)
{
_curEventArgs.Error = eventArgs.Error;
var callBack = (Action<AsyncSocketEventArgs>)eventArgs.UserToken;
if (async) callBack(eventArgs);
return async;
}
private bool ReadBlockLine(int length, AsyncSocketEventArgs args)
{
_block = new byte[length];
_readBytes = 0;
args.Error = null;
args.UserToken = args.Completed;
args.Completed = ReadBlockFromSocketCallBack;
args.DataLength = 0;
return ReadBlockLineTask(false, args);
}
private void RecalculateBufferSize(AsyncSocketEventArgs args)
{
_offset = _offset - _bufferSize;
_bufferSize = args.DataLength;
}
private bool ReadBlockLineTask(bool async, AsyncSocketEventArgs args)
{
if (args.HasError)
return CallSocketOpCompleted(async, args);
while (_readBytes < _block.Length)
{
if (_offset >= _bufferSize)
return ReceiveDataFromSocket(args) || ReadBlockFromSocketCallBack(async, args);
var bytesToCopy = _block.Length - _readBytes;
var bytesInBufferLeft = _bufferSize - _offset;
if (bytesToCopy > bytesInBufferLeft) bytesToCopy = bytesInBufferLeft;
Array.Copy(_readSocketBuffer, _offset, _block, _readBytes, bytesToCopy);
_readBytes += bytesToCopy;
IncrementOffset(bytesToCopy);
}
IncrementOffset(2);
return CallSocketOpCompleted(async, args);
}
private bool ReadLine(AsyncSocketEventArgs args)
{
_firstChar = 0;
_lineBuffer.Clear();
args.DataLength = 0;
args.UserToken = args.Completed;
args.Completed = ReadLineCallBack;
args.Error = null;
return ReadLineTask(false, args);
}
private void ReadLineCallBack(AsyncSocketEventArgs args)
{
ReadLineCallBack(true, args);
}
private bool ReadLineCallBack(bool async, AsyncSocketEventArgs args)
{
args.BufferToReceive = null;
RecalculateBufferSize(args);
if (args.HasError)
ReleaseBuffer();
return ReadLineTask(async, args);
}
public bool Send(AsyncSocketEventArgs eventArgs)
{
_sendAllContext.SentBytes = 0;
_sendAllContext.EventArgs = eventArgs;
eventArgs.Error = null;
_sendArgs.BufferList = eventArgs.BufferList;
_sendArgs.UserToken = _sendAllContext;
var isAsync = _socket.SendAsync(_sendArgs);
if (!isAsync) SendAllCallBack(false,_sendAllContext);
return isAsync;
}
private void ProcessRedisLine(AsyncSocketEventArgs args)
{
ProcessRedisLine(true, args);
}
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 ReadResponseFromStream(bool async, AsyncSocketEventArgs args)
{
args.Completed = ProcessRedisLine;
return(ReadLine(args) || ProcessRedisLine(async, args));
}
public void Receive_CallsSocketReceive()
{
const int bufferSize = 111;
var sock = CreateSocket();
var args = new AsyncSocketEventArgs();
args.BufferToReceive = new byte[bufferSize];
sock.Receive(args);
_socket.Verify(s => s.ReceiveAsync(
It.Is((SocketAsyncEventArgs a) => a.Count == bufferSize &&
a.Offset == 0)));
}
private bool ReadLineTask(bool async, AsyncSocketEventArgs args)
{
if (args.HasError)
return CallSocketOpCompleted(async, args);
while (true)
{
if (_offset >= _bufferSize)
return ReceiveDataFromSocket(args) || ReadLineCallBack(async, args);
var dataByte = _readSocketBuffer[_offset];
IncrementOffset(1);
if (dataByte == '\r')
{
IncrementOffset(1);
return CallSocketOpCompleted(async, args);
}
if (_firstChar == 0)
_firstChar = dataByte;
else
_lineBuffer.Append((char)dataByte);
}
}
private void FlushCallBack(bool async, AsyncSocketEventArgs args)
{
var buffers = (List<ArraySegment<byte>>)args.UserToken;
Interlocked.Exchange(ref _socketException, args.Error);
foreach (var buf in buffers)
_buffersPool.ReleaseWithoutNotification(buf.Array);
if (async) DoFlushing();
_buffersPool.NotifyWaiters();
}
private bool CallOperationCompleted(bool async, AsyncSocketEventArgs eventArgs)
{
_curEventArgs.Error = eventArgs.Error;
_curEventArgs.Response = _redisResponse;
if (async) _curEventArgs.Completed(_curEventArgs);
return async;
}
private void ProcessRedisLine(AsyncSocketEventArgs args)
{
ProcessRedisLine(true, args);
}
private void FlushCallBack(AsyncSocketEventArgs args)
{
FlushCallBack(true, args);
}
private void FlushCallBack(AsyncSocketEventArgs args)
{
FlushCallBack(true, args);
}
private void ReadBlockFromSocketCallBack(AsyncSocketEventArgs args)
{
ReadBlockFromSocketCallBack(true, args);
}
private void ReadLineCallBack(AsyncSocketEventArgs args)
{
ReadLineCallBack(true, args);
}
private bool ReceiveDataFromSocket(AsyncSocketEventArgs args)
{
try
{
if (_buffersPool.TryGet(out _readSocketBuffer,
b =>
{
_readSocketBuffer = b;
args.BufferToReceive = _readSocketBuffer;
if (!_asyncSocket.Receive(args))
args.Completed(args);
}))
{
args.BufferToReceive = _readSocketBuffer;
return _asyncSocket.Receive(args);
}
return true;
}
catch (Exception ex)
{
args.Error = ex;
return false;
}
}
