public override async Task OnConnectedAsync(ConnectionContext connection) { // Use a length prefixed protocol var protocol = new LengthPrefixedProtocol(); var reader = connection.CreateReader(); var writer = connection.CreateWriter(); while (true) { try { var result = await reader.ReadAsync(protocol); var message = result.Message; _logger.LogInformation("Received a message of {Length} bytes", message.Payload.Length); if (result.IsCompleted) { break; } await writer.WriteAsync(protocol, message); } finally { reader.Advance(); } } }
public override async Task OnConnectedAsync(ConnectionContext connection) { IServiceScope scope = null; BlazeClientContext clientContext = null; try { //Create connection scope scope = _serviceScopeFactory.CreateScope(); var messageHandler = scope.ServiceProvider.GetRequiredService <IBlazeMessageHandler>(); clientContext = (BlazeClientContext)scope.ServiceProvider.GetRequiredService <ClientContext>(); clientContext.ConnectionContext = connection; _clientManager.Add(clientContext); var reader = connection.CreateReader(); var writer = connection.CreateWriter(); while (true) { try { var result = await reader.ReadAsync(_protocol); var message = result.Message; if (message != null) { var responses = await messageHandler.ProcessMessage(message, clientContext); if (responses != null) { foreach (var response in responses) { await writer.WriteAsync(_protocol, response); } } } if (result.IsCompleted) { break; } } finally { reader.Advance(); } } } finally { if (clientContext != null) { _clientManager.Remove(clientContext); } scope?.Dispose(); } }
public override async Task OnConnectedAsync(ConnectionContext connection) { ProtocolReader protocolReader = connection.CreateReader(); CustomProtocol customProtocol = new(); string message = "first\n"; Memory <byte> buffer = connection.Transport.Output.GetMemory(0x10)[..0x10];
public override async Task OnConnectedAsync(ConnectionContext connection) { // Use a length prefixed protocol var protocol = new MyRequestMessageReader(); var reader = connection.CreateReader(); while (!_hostApplicationLifetime.ApplicationStopping.IsCancellationRequested) { try { var result = await reader.ReadAsync(protocol); var message = result.Message; if (message is PayloadMessage payloadMessage) { _logger.LogInformation("Received a {MessageType} with an inner payload of {Length} bytes", typeof(PayloadMessage).Name, payloadMessage.Payload.Length); } if (result.IsCompleted) { break; } } finally { reader.Advance(); } } }
public MyClientProtocol(ConnectionContext connection) { _connection = connection; _reader = connection.CreateReader(); _messageWriter = new MyRequestMessageWriter(); }
public CobbleConnection(ConnectionContext context) { _context = context ?? throw new ArgumentNullException(nameof(context)); _reader = context.CreateReader(); _writer = context.CreateWriter(); _protocol = new HandshakingProtocol(); }
public override async Task OnConnectedAsync(ConnectionContext connection) { if (connection is null) { throw new ArgumentNullException(nameof(connection)); } using IDisposable loggerScope = _logger.BeginScope("Peer {PeerId} connected to server {ServerEndpoint}", connection.ConnectionId, connection.LocalEndPoint); ProtocolReader reader = connection.CreateReader(); INetworkProtocolMessageSerializer protocol = _serviceProvider.GetRequiredService <INetworkProtocolMessageSerializer>(); using IPeerContext peerContext = _peerContextFactory.CreateIncomingPeerContext(connection.ConnectionId, connection.LocalEndPoint !.AsIPEndPoint().EnsureIPv6(), connection.RemoteEndPoint !.AsIPEndPoint().EnsureIPv6(), new NetworkMessageWriter(protocol, connection.CreateWriter())); using CancellationTokenRegistration cancellationRegistration = peerContext.ConnectionCancellationTokenSource.Token.Register(() => { connection.Abort(new ConnectionAbortedException("Requested by PeerContext")); }); connection.Features.Set(peerContext); protocol.SetPeerContext(peerContext); if (EnsurePeerCanConnect(connection, peerContext)) { _eventBus.Publish(new PeerConnected(peerContext)); await _networkMessageProcessorFactory.StartProcessorsAsync(peerContext).ConfigureAwait(false); while (true) { try { ProtocolReadResult <INetworkMessage> result = await reader.ReadAsync(protocol).ConfigureAwait(false); if (result.IsCompleted) { break; } await ProcessMessageAsync(result.Message, peerContext, connection.ConnectionClosed).ConfigureAwait(false); } catch (Exception ex) { _logger.LogDebug(ex, "Unexpected connection terminated because of {DisconnectionReason}.", ex.Message); break; } finally { reader.Advance(); } } return; } }
private HubProtocol(ConnectionContext connection, int?maximumMessageSize, IHubProtocol hubProtocol, IInvocationBinder invocationBinder) { _connection = connection; _protocolReader = connection.CreateReader(); _protocolWriter = connection.CreateWriter(); _hubMessageReader = new HubMessageReader(hubProtocol, invocationBinder); _hubMessageWriter = new HubMessageWriter(hubProtocol); _maximumMessageSize = maximumMessageSize; }
public async Task ConnectAsync(EndPoint endPoint) { // REVIEW: Should this be a static factory? _connection = await _client.ConnectAsync(endPoint).ConfigureAwait(false); _writer = _connection.CreateWriter(); _reader = _connection.CreateReader(); _readingTask = ProcessReadsAsync(); }
public MemcachedProtocol(ConnectionContext connection) { _connection = connection; _protocolReader = connection.CreateReader(); _protocolWriter = connection.CreateWriter(); _semaphore = new SemaphoreSlim(1); _memcachedMessageWriter = new MemcachedMessageWriter(); _memcachedMessageReader = new MemcachedMessageReader(); }
/// <summary> /// on connected as an asynchronous operation. /// </summary> /// <param name="connection">The new <see cref="T:Microsoft.AspNetCore.Connections.ConnectionContext" /></param> /// <returns>A Task representing the asynchronous operation.</returns> /// <autogeneratedoc /> public override async Task OnConnectedAsync(ConnectionContext connection) { var protocol = _messageReader; var reader = connection.CreateReader(); while (!connection.ConnectionClosed.IsCancellationRequested) { try { var result = await reader.ReadAsync(protocol); var message = result.Message; var returnMessage = _messageHandler.HandleMessage(connection, message); if (returnMessage == null) { continue; } try { await _messageSender.TrySendAsync(returnMessage, connection.ConnectionClosed); } catch (ConnectionNotFoundException e) { _logger.LogError($"connection not found: {e.Message}"); } catch (ArgumentNullException e) { _logger.LogError($"Client {connection.ConnectionId} threw: Argument null exception: {e.Message}"); } catch (Exception e) { _logger.LogError($"Connection {connection.ConnectionId} threw: {e.Message} /n trace: {e.StackTrace}"); } if (result.IsCompleted) { break; } } catch (ConnectionResetException) { var newSource = new CancellationTokenSource(); newSource.Cancel(); connection.ConnectionClosed = newSource.Token; } }
public HttpClientProtocol(ConnectionContext connection) { _connection = connection; _reader = connection.CreateReader(); (string host, int port) = connection.RemoteEndPoint switch { UriEndPoint uriEndPoint => (uriEndPoint.Uri.Host, uriEndPoint.Uri.Port), IPEndPoint ip => (ip.Address.ToString(), ip.Port), _ => throw new NotSupportedException($"{connection.RemoteEndPoint} not supported") }; _messageWriter = new Http1RequestMessageWriter(host, port); }
/// <summary> /// on connected as an asynchronous operation. /// </summary> /// <param name="connection">The new <see cref="T:Microsoft.AspNetCore.Connections.ConnectionContext" /></param> /// <returns>A <see cref="T:System.Threading.Tasks.Task" /> that represents the connection lifetime. When the task completes, the connection is complete.</returns> public override async Task OnConnectedAsync(ConnectionContext connection) { this.context = connection; this.reader = connection.CreateReader(); this.writer = connection.CreateWriter(); SessionManager.Singleton.AcceptSession(connection, writer, this.protocol); //IConnectionHeartbeatFeature heartbeatFeature = connection.Features.Get<IConnectionHeartbeatFeature>(); //heartbeatFeature.OnHeartbeat(this.SendHeartbeat, null); while (true) { try { var result = await reader.ReadAsync(protocol); var message = result.Message; _logger.LogInformation("Received a message of {Length} bytes", message.Payload.Length); if (result.IsCompleted) { break; } await writer.WriteAsync(protocol, message); } catch (Exception ex) { _logger.LogError(ex.Message); connection.Abort(); break; } finally { reader.Advance(); } } }
private async Task ProcessInbound(CancellationToken cancellationToken) { await Task.Yield(); var protocolReader = connection.CreateReader(); var opReader = new NatsOperationReader(); while (!cancellationToken.IsCancellationRequested) { try { var result = await protocolReader.ReadAsync(opReader, cancellationToken).ConfigureAwait(false); if (result.IsCompleted) { Console.WriteLine("inbound connection closed"); break; } protocolReader.Advance(); await operationHandler.HandleOperation(result.Message); } catch (OperationCanceledException) { /* ignore cancellation */ } catch (Exception) { if (!connection.ConnectionClosed.IsCancellationRequested) { throw; } break; } } Console.WriteLine("!!! exit inbound"); operationHandler.ConnectionClosed(); }
public RespBedrockProtocol(ConnectionContext connection, object state = null) : base(state) { // _connection = connection; _reader = connection.CreateReader(); _writer = connection.CreateWriter(); }
public RabbitMQClientProtocol(ConnectionContext connection) { _writer = connection.CreateWriter(); _reader = connection.CreateReader(); _formatter = new RabbitMQMessageFormatter(); }
public RedisProtocol(ConnectionContext connection) { _writer = connection.CreateWriter(); _reader = connection.CreateReader(); _commandWriter = new RedisCommandWriter(); }
public RabbitMQProtocolReader(ConnectionContext ctx) { _protocol = ctx.CreateReader(); }
public HttpClientProtocol(ConnectionContext connection) { _connection = connection; _reader = connection.CreateReader(); }
public RespBedrockProtocol(ConnectionContext connection) { // _connection = connection; _reader = connection.CreateReader(); _writer = connection.CreateWriter(); }
public override async Task OnConnectedAsync(ConnectionContext connection) { // TODO: we could register processors as Scoped per connection and create a scope here //using var serviceProviderScope = serviceProvider.CreateScope(); if (connection is null) { throw new ArgumentNullException(nameof(connection)); } using IDisposable logScope = _logger.BeginScope("Peer {PeerId} connected to outbound {PeerEndpoint}", connection.ConnectionId, connection.LocalEndPoint); ProtocolReader reader = connection.CreateReader(); INetworkProtocolMessageSerializer protocol = _serviceProvider.GetRequiredService <INetworkProtocolMessageSerializer>(); using IPeerContext peerContext = _peerContextFactory.CreateOutgoingPeerContext(connection.ConnectionId, connection.LocalEndPoint !, connection.Features.Get <OutgoingConnectionEndPoint>(), new NetworkMessageWriter(protocol, connection.CreateWriter())); connection.ConnectionClosed = peerContext.ConnectionCancellationTokenSource.Token; connection.Features.Set(peerContext); protocol.SetPeerContext(peerContext); _eventBus.Publish(new PeerConnected(peerContext)); await _networkMessageProcessorFactory.StartProcessorsAsync(peerContext).ConfigureAwait(false); while (true) { if (connection.ConnectionClosed.IsCancellationRequested) { break; } try { ProtocolReadResult <INetworkMessage> result = await reader.ReadAsync(protocol, connection.ConnectionClosed).ConfigureAwait(false); if (result.IsCompleted) { break; } await ProcessMessageAsync(result.Message, peerContext, connection.ConnectionClosed) .WithCancellationAsync(connection.ConnectionClosed) .ConfigureAwait(false); } catch (OperationCanceledException) { break; } catch (Exception e) { _logger.LogError(new EventId(0), e, e.Message); throw; } finally { reader.Advance(); } } return; }
public override async Task OnConnectedAsync(ConnectionContext connection) { IServiceScope scope = null; BlazeClientContext clientContext = null; try { //Create connection scope scope = _serviceScopeFactory.CreateScope(); var messageHandler = scope.ServiceProvider.GetRequiredService <IBlazeMessageHandler>(); clientContext = (BlazeClientContext)scope.ServiceProvider.GetRequiredService <ClientContext>(); clientContext.ConnectionContext = connection; clientContext.Reader = connection.CreateReader(); clientContext.Writer = connection.CreateWriter(); _clientManager.Add(clientContext); while (true) { try { var result = await clientContext.Reader.ReadAsync(_protocol); var message = result.Message; if (message != null) { var response = await messageHandler.ProcessMessage(message); if (response != null) { await clientContext.Writer.WriteAsync(_protocol, response); } //Send new notifications while (clientContext.PendingNotifications.TryDequeue(out var notification)) { await clientContext.Writer.WriteAsync(_protocol, notification); } } if (result.IsCompleted) { break; } } finally { clientContext.Reader.Advance(); } } } finally { if (clientContext != null) { _clientManager.Remove(clientContext); } scope?.Dispose(); } }
public override async Task OnConnectedAsync(ConnectionContext connection) { Logger.Debug($"Redirecting to {_proxySettings.RedirectHost} {_proxySettings.RedirectIp}:{_proxySettings.LocalPort}"); var blazeProtocol = new BlazeProxyProtocol(); var localReader = connection.CreateReader(); var localWriter = connection.CreateWriter(); while (true) { try { var result = await localReader.ReadAsync(blazeProtocol); var message = result.Message; if (message != null) { if (message.Header.Component == BlazeComponent.Redirector && message.Header.Command == (ushort)RedirectorCommand.ServerInfo) { var hostBytes = new List <byte>(Encoding.ASCII.GetBytes(_proxySettings.RedirectHost)); var payload = new List <byte>(); payload.AddRange(new byte[] { 0x86, 0x49, 0x32, //ADDR 0xD0, 0x00, //union(0) 0xDA, 0x1B, 0x35, //VALU 0x00, //start struct 0xA2, 0xFC, 0xF4, //HOST }); payload.AddRange(GetStringLengthBytes((uint)hostBytes.Count + 1)); payload.AddRange(hostBytes); payload.AddRange(new byte[] { 0x00, //endbyte for string 0xA7, 0x00, 0x00, //IP 0x74, //uint32 }); var ipBytes = BitConverter.GetBytes(Convert.ToUInt32(IPAddress.Parse(_proxySettings.RedirectIp).Address)); Array.Reverse(ipBytes); //big endian payload.AddRange(ipBytes); payload.AddRange(new byte[] { 0xC2, 0xFC, 0xB4, //PORT 0x52, //uint16 }); var portBytes = BitConverter.GetBytes(Convert.ToUInt16(_proxySettings.LocalPort)); Array.Reverse(portBytes); //big endian payload.AddRange(portBytes); payload.AddRange(new byte[] { 0x00, //end struct 0xCE, 0x58, 0xF5, //SECU 0x21, //int8 0x00, //0 0xE2, 0x4B, 0xB3, //XDNS 0x74, //uint32 0x00, 0x00, 0x00, 0x00, //0 }); var response = new BlazeMessageData { Header = new BlazeHeader { Command = message.Header.Command, Component = message.Header.Component, MessageType = BlazeMessageType.Reply, MessageId = message.Header.MessageId, ErrorCode = 0 }, Payload = new ReadOnlySequence <byte>(payload.ToArray()) }; await localWriter.WriteAsync(blazeProtocol, response); } } if (result.IsCompleted) { break; } } finally { localReader.Advance(); } } }
public override async Task OnConnectedAsync(ConnectionContext connection) { Logger.Debug($"Connecting to {_proxySettings.RemoteHost}:{_proxySettings.RemotePort}"); var proxyClient = new TcpClient(); await proxyClient.ConnectAsync(_proxySettings.RemoteHost, _proxySettings.RemotePort); var ogStream = proxyClient.GetStream(); Stream proxyStream = ogStream; if (_proxySettings.Secure) { var protocol = new TlsClientProtocol(proxyStream, new Org.BouncyCastle.Security.SecureRandom()); protocol.Connect(new BlazeTlsClient()); proxyStream = protocol.Stream; } var blazeProtocol = new BlazeProxyProtocol(); var localReader = connection.CreateReader(); var localWriter = connection.CreateWriter(); var remoteReader = new ProtocolReader(proxyStream); var remoteWriter = new ProtocolWriter(proxyStream); while (true) { try { var result = await localReader.ReadAsync(blazeProtocol); var message = result.Message; if (message != null) { var header = message.Header; Logger.Debug( $"Client -> Proxy; Length:{header.Length} Component:{header.Component} Command:0x{header.Command:X2} ErrorCode:{header.ErrorCode} MessageType:{header.MessageType} MessageId:{header.MessageId}"); var requestPayload = message.Payload; if (!requestPayload.IsEmpty) { if (!_parser.TryParseBody(requestPayload)) { Logger.Error("Failed to parse request message"); } } await remoteWriter.WriteAsync(blazeProtocol, message); } if (result.IsCompleted) { break; } } finally { localReader.Advance(); } do { try { var result = await remoteReader.ReadAsync(blazeProtocol); var message = result.Message; if (message != null) { var header = message.Header; Logger.Debug( $"Proxy <- Server; Length:{header.Length} Component:{header.Component} Command:0x{header.Command:X2} ErrorCode:{header.ErrorCode} MessageType:{header.MessageType} MessageId:{header.MessageId}"); var responsePayload = message.Payload; if (!responsePayload.IsEmpty) { if (!_parser.TryParseBody(responsePayload)) { Logger.Error("Failed to parse response message"); } } await localWriter.WriteAsync(blazeProtocol, message); } if (result.IsCompleted) { break; } } finally { remoteReader.Advance(); } } while (ogStream.DataAvailable); } }
public override async Task OnConnectedAsync(ConnectionContext connection) { var protocol = new MessageReaderWriter(); var reader = connection.CreateReader(); var writer = connection.CreateWriter(); var connectionTopics = new List <string>(); try { while (true) { var result = await reader.ReadAsync(protocol); var message = result.Message; if (result.IsCompleted) { break; } switch (message.MessageType) { case MessageType.Publish: { if (_topics.TryGetValue(message.Topic, out var topic)) { var data = new Message { MessageType = MessageType.Data, Payload = message.Payload, Topic = message.Topic }; topic.IncrementPublish(); // TODO: Use WhenAll foreach (var pair in topic) { await pair.Value.WriteAsync(protocol, data); } } await writer.WriteAsync(protocol, new Message { Id = message.Id, Topic = message.Topic, MessageType = MessageType.Success }); } break; case MessageType.Subscribe: { var topic = _topics.GetOrAdd(message.Topic); topic.Add(connection.ConnectionId, writer); connectionTopics.Add(message.Topic); await writer.WriteAsync(protocol, new Message { Id = message.Id, Topic = message.Topic, MessageType = MessageType.Success }); } break; case MessageType.Unsubscribe: { RemoveTopic(connection, connectionTopics, message.Topic); await writer.WriteAsync(protocol, new Message { Id = message.Id, Topic = message.Topic, MessageType = MessageType.Success }); } break; default: break; } reader.Advance(); } } finally { for (int i = connectionTopics.Count - 1; i >= 0; i--) { RemoveTopic(connection, connectionTopics, connectionTopics[i]); } } }