public ClientWebSocketHandler(WebSocketTransport webSocketTransport) : base(maxIncomingMessageSize: null) { Debug.Assert(webSocketTransport != null, "webSocketTransport is null"); _webSocketTransport = webSocketTransport; }
public void AbortUrlTriggersContentTypeSet() { var request = new Mock <IRequest>(); var qs = new NameValueCollection(); request.Setup(m => m.QueryString).Returns(new NameValueCollectionWrapper(qs)); request.Setup(m => m.LocalPath).Returns("/test/echo/abort"); var response = new Mock <IResponse>(); var counters = new Mock <IPerformanceCounterManager>(); var heartBeat = new Mock <ITransportHeartbeat>(); var hostContext = new HostContext(request.Object, response.Object); var transportConnection = new Mock <ITransportConnection>(); var traceManager = new Mock <ITraceManager>(); var transport = new WebSocketTransport(hostContext, null, heartBeat.Object, counters.Object, traceManager.Object, null, null); transport.ProcessRequest(transportConnection.Object).Wait(); response.VerifySet(r => r.ContentType = It.IsAny <string>(), "ContentType not set"); }
public async Task ShouldSupportCustomTransport() { var customTransportCreated = false; var options = new ConnectOptions() { BrowserWSEndpoint = Browser.WebSocketEndpoint, TransportFactory = (url, opt, cancellationToken) => { customTransportCreated = true; return(WebSocketTransport.DefaultTransportFactory(url, opt, cancellationToken)); } }; await using (await Puppeteer.ConnectAsync(options, TestConstants.LoggerFactory)) { Assert.True(customTransportCreated); } }
public async Task ConnectAsync(WebSocket webSocket, string connectionId, string connectorName = "") { var receiverContext = new WebSocketReceiverContext { Compressor = _compressor, ConnectionId = connectionId, LoggerFactory = _loggerFactory, WebSocket = webSocket }; WebSocketTransport transport = null; if (Connections.TryGetValue(connectionId, out transport)) { transport.ReConnect(webSocket); List <MessageHolder> messages = _lifetimeManager.TryDequeue(connectionId); foreach (var message in messages) { await SendAsync(transport, new WebSocketMessageDescriptor { MessageType = WebSocketMessageType.Text, Segments = message.Segments, EndOfMessage = true, IsQueue = true, }); } } else { transport = new WebSocketTransport(webSocket, connectionId, connectorName); var context = new WebSocketMessageContext(); context.Command = WebSocketCommands.Handshake; context.Value = connectionId; context.Header = await _initState.GetStateAsync(); Connections.TryAdd(connectionId, transport); await SendAsync(connectionId, context); } var receiver = new WebSocketReceiver(_serviceProvider, receiverContext, CloseConnection); await receiver.ReceiveAsync(); }
public void CloseConnection(string connectionId, bool keepAlive) { WebSocketTransport transport = null; if (keepAlive) { if (Connections.TryGetValue(connectionId, out transport)) { transport.Dispose(); } } else { if (Connections.TryRemove(connectionId, out transport)) { transport.Dispose(); } } }
private Task SendBinaryAsync(WebSocketTransport transport, byte[] chunkedBytes, bool endOfMessage) { if (transport == null) { throw new ArgumentNullException(nameof(transport)); } var segments = new ArraySegment <byte>(chunkedBytes); if (!transport.WebSocket.CloseStatus.HasValue) { return(transport.WebSocket.SendAsync(segments, WebSocketMessageType.Binary, endOfMessage, CancellationToken.None)); } return(TaskCache.CompletedTask); }
public async Task ConnectAsync(WebSocket webSocket, string connectionId, string connectorName = "", CancellationToken cancellationToken = default(CancellationToken)) { if (cancellationToken != CancellationToken.None) { cancellationToken.Register(() => { CancellationGraceful(); }); } var receiverContext = new WebSocketReceiverContext { Compressor = _compressor, ConnectionId = connectionId, LoggerFactory = _loggerFactory, WebSocket = webSocket, InvocatorContext = InvocatorContext }; if (Connections.TryGetValue(connectionId, out WebSocketTransport transport)) { transport.ReConnect(webSocket); } else { transport = new WebSocketTransport(webSocket, connectionId, connectorName); var context = new WebSocketMessageContext(); context.Command = WebSocketCommands.Handshake; context.Value = connectionId; context.Header = await _initState.GetStateAsync(); Connections.TryAdd(connectionId, transport); await SendAsync(connectionId, context); } var receiver = new WebSocketReceiver(_serviceProvider, receiverContext, CloseConnection, _loggerFactory); await receiver.ReceiveAsync(cancellationToken); }
public void WebSocketSendReturnsAFaultedTaskWhenNotConnected(WebSocketState state) { var mockConnection = new Mock <Client.IConnection>(MockBehavior.Strict); var mockWebSocket = new Mock <WebSocket>(MockBehavior.Strict); mockWebSocket.SetupGet(ws => ws.State).Returns(state); mockConnection.Setup(c => c.OnError(It.IsAny <InvalidOperationException>())); var wsTransport = new WebSocketTransport(); wsTransport.WebSocket = mockWebSocket.Object; var task = wsTransport.Send(mockConnection.Object, "", ""); Assert.True(task.IsFaulted); Assert.IsType(typeof(InvalidOperationException), task.Exception.InnerException); mockConnection.VerifyAll(); mockWebSocket.VerifyAll(); }
async Task HandleListenerContextAsync(HttpListenerContext context) { WebSocket webSocket = null; try { var wsContext = await context.AcceptWebSocketAsync(WebSocketTransport.WebSocketSubProtocol); var wsTransport = new WebSocketTransport(wsContext.WebSocket); await this.listener.HandleTransportAsync(wsTransport); } catch (Exception exception) { Trace.WriteLine(TraceLevel.Error, exception.ToString()); if (webSocket != null) { webSocket.Abort(); } } }
public SimpleServer() { ITransport websocketTransport = new WebSocketTransport(); TransportRegistry.Instance.RegisterTransport(websocketTransport); IProtocol jsonRpc = new JsonRpcProtocol(); IProtocol fivesJson = new FiVESJsonProtocol(); ProtocolRegistry.Instance.RegisterProtocol(jsonRpc); ProtocolRegistry.Instance.RegisterProtocol(fivesJson); SINFONIServer newServer = new SINFONIServer("localhost", 8080, "/service/", "server.sinfoni"); var service = newServer.StartService("127.0.0.1", 34568, "/service", "ws", "jsonrpc"); service.OnNewClient += new NewClient(HandleNewClient); service["example.addVectors"] = (Func <Vector, Vector, Vector>)addVectors; Console.Read(); }
public async Task WebSocketTransport_WhatIsReceivedIsWritten() { var pipePair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default); using (var webSocketFeature = new TestWebSocketConnectionFeature()) { // Build transport var transport = new WebSocketTransport(await webSocketFeature.AcceptAsync(), pipePair.Application, NullLogger.Instance); // Accept web socket, start receiving / sending at the transport level var processTask = transport.ConnectAsync(CancellationToken.None); // Start a socket client that will capture traffic for posterior analysis var clientTask = webSocketFeature.Client.ExecuteAndCaptureFramesAsync(); // Send a frame, then close await webSocketFeature.Client.SendAsync( buffer : new ArraySegment <byte>(Encoding.UTF8.GetBytes("Hello")), messageType : WebSocketMessageType.Binary, endOfMessage : true, cancellationToken : CancellationToken.None); await webSocketFeature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); var result = await pipePair.Transport.Input.ReadAsync(); var buffer = result.Buffer; Assert.Equal("Hello", Encoding.UTF8.GetString(buffer.ToArray())); pipePair.Transport.Input.AdvanceTo(buffer.End); pipePair.Transport.Output.Complete(); // The transport should finish now await processTask; // The connection should close after this, which means the client will get a close frame. var clientSummary = await clientTask; Assert.Equal(WebSocketCloseStatus.NormalClosure, clientSummary.CloseResult.CloseStatus); } }
/// <summary> /// Creates and starts opening/upgrading process of the transports. /// </summary> private void CreateTransports() { bool hasWSSupport = Handshake.Upgrades.Contains("websocket"); if (hasWSSupport) { Transport = new WebSocketTransport(this); } Poller = new PollingTransport(this); Poller.Open(); if (Transport == null) { Transport = Poller as ITransport; } else { Transport.Open(); } }
/// <summary> /// This function will begin to open the Socket.IO connection by sending out the handshake request. /// If the Options' AutoConnect is true, it will be called automatically. /// </summary> public void Open() { if (State != States.Initial && State != States.Closed && State != States.Reconnecting) { return; } HTTPManager.Logger.Information("SocketManager", "Opening"); ReconnectAt = DateTime.MinValue; switch (Options.ConnectWith) { case TransportTypes.Polling: Transport = new PollingTransport(this); break; #if !BESTHTTP_DISABLE_WEBSOCKET case TransportTypes.WebSocket: Transport = new WebSocketTransport(this); break; #endif } Transport.Open(); (this as IManager).EmitEvent("connecting"); State = States.Opening; ConnectionStarted = DateTime.UtcNow; HTTPManager.Heartbeats.Subscribe(this); // The root namespace will be opened by default GetSocket("/"); }
public static async Task <IConnectionTransport> CreateTransportAsync(ConnectOptions options) { if (!string.IsNullOrEmpty(options.BrowserWSEndpoint) && options.TransportFactory != null) { throw new ArgumentException("Exactly one of BrowserWSEndpoint or TransportFactory must be passed to connect"); } IConnectionTransport transport = null; if (options.TransportFactory != null) { transport = await options.TransportFactory(new Uri(options.BrowserWSEndpoint), options).ConfigureAwait(false); } else if (!string.IsNullOrEmpty(options.BrowserWSEndpoint)) { #pragma warning disable CA2000 // Call dispose, this is a false alarm. transport = await WebSocketTransport.CreateAsync(options).ConfigureAwait(false); #pragma warning restore CA2000 } return(SlowMoTransport.Wrap(transport, options.SlowMo)); }
public Task SendAsync(string connectionId, WebSocketMessageContext context) { if (!Connections.Any()) { return(TaskCache.CompletedTask); } WebSocketTransport transport = null; if (!Connections.TryGetValue(connectionId, out transport)) { throw new ArgumentOutOfRangeException(nameof(transport)); } var segments = context.ToSegment(); var descriptor = new WebSocketMessageDescriptor { Segments = segments, EndOfMessage = true, MessageType = WebSocketMessageType.Text }; return(SendAsync(transport, descriptor)); }
internal async Task ConnectInternalAsync(Func <WebSocketTransport, Task> connectFunc, CancellationToken cancellationToken) { CheckDisposed(); TimerAwaitable timer = null; Task timerTask = null; try { // Pipes _duplexPipePair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default); // Transport var transport = new WebSocketTransport(_duplexPipePair.Application, _logger); // Application _transportHandler = new TransportHandler(_duplexPipePair.Transport, _logger); // Session _session = new StreamingSession(_requestHandler, _transportHandler, _logger, cancellationToken); // Set up cancellation _disconnectCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); // Start transport and application var transportTask = connectFunc(transport); var applicationTask = _transportHandler.ListenAsync(_disconnectCts.Token); var combinedTask = Task.WhenAll(transportTask, applicationTask); Log.ClientStarted(_logger, _url ?? string.Empty); // Periodic task: keep alive // Disposed with `timer.Stop()` in the finally block below if (_keepAlive.HasValue) { timer = new TimerAwaitable(_keepAlive.Value, _keepAlive.Value); timerTask = TimerLoopAsync(timer); } // We are connected! IsConnected = true; // Block until transport or application ends. await combinedTask.ConfigureAwait(false); // Signal that we're done _disconnectCts.Cancel(); Log.ClientTransportApplicationCompleted(_logger, _url); } finally { timer?.Stop(); if (timerTask != null) { await timerTask.ConfigureAwait(false); } } Log.ClientCompleted(_logger, _url ?? string.Empty); }
private void RegisterModules() { var JsonRPCProtocol = new JsonRpcProtocol(); var FiVESJsonProtocol = new FiVESJsonProtocol(); var WebsocketTransport = new WebSocketTransport(); KIARA.ProtocolRegistry.Instance.RegisterProtocol(JsonRPCProtocol); KIARA.ProtocolRegistry.Instance.RegisterProtocol(FiVESJsonProtocol); KIARA.TransportRegistry.Instance.RegisterTransport(WebsocketTransport); }
async Task HandleListenerContextAsync(HttpListenerContext context) { WebSocket webSocket = null; try { var wsContext = await context.AcceptWebSocketAsync(WebSocketTransport.WebSocketSubProtocol); var wsTransport = new WebSocketTransport(wsContext.WebSocket); await this.listener.HandleTransportAsync(wsTransport); } catch(Exception exception) { Trace.WriteLine(TraceLevel.Error, exception.ToString()); if (webSocket != null) { webSocket.Abort(); } } }