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; }
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; }
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); } }