private static RedisBaseReader CreateRedisReader(int chunkSize, IAsyncSocket socket)
{
var bufferManager = new BufferManager(2, chunkSize, 2, 10);
var redisReader = new RedisSocketReader(socket, bufferManager);
return(redisReader);
}
private IRedisPipeline CreateSocketPipeline(int index, IAsyncSocket asyncSocket)
{
var redisReader = new RedisSocketReader(asyncSocket, _bufferManager);
var redisWriter = new RedisSocketWriter(asyncSocket, _bufferManager);
return(new RedisPipeline(index, asyncSocket, null, redisWriter, redisReader, _socketTimeout));
}
/// <summary>
/// Construtor
/// </summary>
/// <param name="asyncServerSocket"></param>
/// <param name="cfg"></param>
/// <param name="socket"></param>
/// <param name="buffer"></param>
internal AsyncState(IAsyncSocket asyncServerSocket, SocketCfg cfg, System.Net.Sockets.Socket socket, byte[] buffer)
{
AsyncSocket = asyncServerSocket;
Socket = socket;
Buffer = buffer;
Cfg = cfg;
switch (cfg.ProtocolType)
{
case ProtocolType.TCP:
ConfigureTcp(cfg);
break;
case ProtocolType.UDP:
ConfigureUdp(cfg);
break;
case ProtocolType.SDP:
ConfigureSdp(cfg);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void SetupSocketResponse(IAsyncSocket socket, params string[] dataString)
{
SetupConnectAsync(socket);
SetupSendAsync(socket);
var awaitable = Substitute.For <ISocketAwaitable <ArraySegment <byte> > >();
awaitable.GetAwaiter().Returns(awaitable);
awaitable.IsCompleted.Returns(true);
var i = 0;
awaitable.GetResult().Returns(
(context) =>
{
if (i >= dataString.Length)
{
return(new ArraySegment <byte>(new byte[0]));
}
var data = new ArraySegment <byte>(dataString[i].ToBytes());
i++;
return(data);
});
socket.Connected.Returns(true);
socket.ReceiveAsync(Arg.Any <ArraySegment <byte> >()).Returns(awaitable);
}
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;
}
private static void SetupConnectAsync(IAsyncSocket socket)
{
var awaitable = Substitute.For <ISocketAwaitable <bool> >();
awaitable.GetAwaiter().Returns(awaitable);
awaitable.IsCompleted.Returns(true);
awaitable.GetResult().Returns(true);
socket.ConnectAsync().Returns(awaitable);
}
public RedisPipeline(IAsyncSocket asyncSocket, IRedisSender redisSender, IRedisReceiver redisReceiver)
{
_asyncSocket = asyncSocket;
_redisSender = redisSender;
_redisReceiver = redisReceiver;
_readArgs.Completed = ItemReceiveProcessDone;
_sendArgs.Completed = ItemSendProcessDone;
_flushChannelArgs.Completed = BufferFlushProcessDone;
}
public RedisPipeline(int pipelineId, IAsyncSocket socket, Stream stream, IRedisWriter redisWriter, IRedisReader redisReader, int socketTimeout = 60000)
{
_pipelineId = pipelineId;
_socket = socket;
_stream = stream;
_redisWriter = redisWriter;
_redisReader = redisReader;
_socketTimeout = socketTimeout;
}
public RedisPipeline(IAsyncSocket asyncSocket, IRedisSender redisSender, IRedisReceiver redisReceiver)
{
_asyncSocket = asyncSocket;
_redisSender = redisSender;
_redisReceiver = redisReceiver;
_readArgs.Completed = ItemReceiveProcessDone;
_sendArgs.Completed = ItemSendProcessDone;
_flushChannelArgs.Completed = BufferFlushProcessDone;
}
private static void SetupSendAsync(IAsyncSocket socket)
{
var awaitable = Substitute.For <ISocketAwaitable <int> >();
awaitable.GetAwaiter().Returns(awaitable);
awaitable.IsCompleted.Returns(true);
awaitable.GetResult().Returns(1);
socket.SendAsync(Arg.Any <IList <ArraySegment <byte> > >()).Returns(awaitable);
}
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 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 NetworkClient(IPacketProcessActions packetProcessActions,
IPacketHandlingActions packetHandlingActions,
INumberEncoderService numberEncoderService,
ILoggerProvider loggerProvider)
{
_packetProcessActions = packetProcessActions;
_packetHandlingActions = packetHandlingActions;
_numberEncoderService = numberEncoderService;
_loggerProvider = loggerProvider;
_socket = new AsyncSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_backgroundReceiveCTS = new CancellationTokenSource();
}
private void btn_server_Click(object sender, EventArgs e)
{
try{
btn_client.Enabled = false;
btn_server.Enabled = false;
var ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
var ipAddress = ipHostInfo.AddressList[0];
_connection = new AsyncServer(new IPEndPoint(ipAddress, int.Parse(tb_port.Text)), Update, HandleError);
}
catch (Exception ex)
{
HandleError(ex);
}
}
private async Task <IRedisPipeline> CreateSslPipelineAsync(int index, string host, IAsyncSocket asyncSocket)
{
var stream = new AsyncSocketStream(asyncSocket);
var sslStream = new SslStream(stream);
var passThrough = new PassThroughStream(sslStream); // required for .net 4.62
await sslStream.AuthenticateAsClientAsync(host).ConfigureAwait(false);
var redisReader = new RedisStreamReader(passThrough, _bufferManager);
var redisWriter = new RedisStreamWriter(passThrough, _bufferManager);
return(new RedisPipeline(index, asyncSocket, passThrough, redisWriter, redisReader, _socketTimeout));
}
public RedisSocketWriter(IAsyncSocket socket, IBufferManager bufferManager)
: base(bufferManager)
{
_socket = socket;
}
public RedisSocketReader(IAsyncSocket asyncSocket, IBufferManager bufferManager)
: base(bufferManager)
{
_asyncSocket = asyncSocket;
}
public static void SendPacket(IAsyncSocket socket, Packet packet)
{
socket.SendAsync(WrapPacket(packet));
}
public void RemoveTarget(IAsyncSocket socket)
{
LightEvent e;
_connectedClients.TryRemove(socket, out e);
PlayerEndPoint endPoint;
if (_playerEndPoints.TryRemove(socket.IpEndPoint, out endPoint))
{
BoDConsole.WriteLine($"Client: {socket.IpEndPoint.Address.MapToIPv4()}:{socket.IpEndPoint.Port} disconnected.");
// If any PlayerEndPoint, other than the one that was just removed,
// references PlayerId, the player must be connected on another PlayerEndPoint.
if (_playerEndPoints.Values.All(p => p.PlayerId != endPoint.PlayerId))
{
Game game;
if (BoDService.PlayerIngame.TryRemove(endPoint.PlayerId, out game))
{
game.RemovePlayer(endPoint.PlayerId);
}
}
}
socket.Dispose();
}
public void Connect(ConnectionToken token)
{
var connectionString = String.Format(ConnectionStringTemplate, token.Key, StormFrontVersion, Environment.OSVersion.Platform);
_asyncSocket = _services.Get<IAsyncSocket>();
_asyncSocket.ReceiveMessage += HandleReceiveMessage;
_asyncSocket.Connect(token.GameHost, token.GamePort);
_asyncSocket.SendMessage(connectionString);
}
public PacketProtocol(IAsyncSocket socket)
{
this.Socket = socket;
this.lenghtBuffer = new byte[sizeof(int)];
}
/// <summary>
/// Awaits a message from the client containing a sessionId.
/// If the sessionId matches any we have given out. Assign the found PlayerEndPoint
/// to the client. We write back the sessionId again as a signal that the client should
/// begin attempting to "connect" with UDP.
/// </summary>
/// <param name="socket"> The TCP socket for the client. </param>
/// <returns> true if the client succesfully verified through TCP. false otherwise. </returns>
private async Task<bool> AddTCPTarget(IAsyncSocket socket)
{
ReadResult result = await socket.ReceiveAsync();
if (result.BytesRead != SESSIONID_LENGTH)
{
return false;
}
string sessionId = Convert.ToBase64String(result.Buffer);
PlayerEndPoint playerEndPoint;
if (!_playerSessionTokens.TryGetValue(sessionId, out playerEndPoint))
{
return false;
}
if (sessionId != playerEndPoint.SessionId)
return false;
playerEndPoint.TCPSocket = socket;
await socket.SendMessage(result.Buffer);
return _playerEndPoints.TryAdd(socket.IpEndPoint, playerEndPoint);
}
public AsyncSocketStream(IAsyncSocket socket)
{
_socket = socket;
}
private Task <IRedisPipeline> CreatePipelineAsync(int index, string host, IAsyncSocket asyncSocket)
{
return(_configuration.UseSsl ?
CreateSslPipelineAsync(index, host, asyncSocket) : Task.FromResult(CreateSocketPipeline(index, asyncSocket)));
}
private async Task ReceiveFromClientAsync(IAsyncSocket s)
{
while (true)
{
ReadResult result = await s.ReceiveAsync();
LightEvent e;
if (_connectedClients.TryGetValue(s, out e))
{
// Reset the LightEvent's timer to prevent timeout.
e.Reset();
}
Read(result.Buffer, s.IpEndPoint);
}
}
