public void StartExceptionStopsAutoTransportFallback() { var errorTcs = new TaskCompletionSource <IResponse>(); errorTcs.SetException(new StartException()); var failingTransport = new Mock <IClientTransport>(); failingTransport.Setup(t => t.Start(It.IsAny <IConnection>(), It.IsAny <string>(), CancellationToken.None)) .Returns(errorTcs.Task) .Verifiable(); var unusedTransport = new Mock <IClientTransport>(); var transports = new List <IClientTransport>(); transports.Add(failingTransport.Object); transports.Add(unusedTransport.Object); var autoTransport = new AutoTransport(new DefaultHttpClient(), transports); var startTask = autoTransport.Start(new Connection("http://foo"), string.Empty, CancellationToken.None); failingTransport.Verify(); unusedTransport.Verify(t => t.Start(It.IsAny <IConnection>(), It.IsAny <string>(), CancellationToken.None), Times.Never()); Assert.IsType(typeof(StartException), startTask.Exception.InnerException); }
/// <summary> /// Sets up the SignalR streaming connection. /// </summary> Task CreateStreamingConnection() { // Establish connection var transport = new AutoTransport(new DefaultHttpClient()); // Add context id and access token to the connection URL var queryStringData = new Dictionary <string, string> { { "authorization", HttpUtility.UrlEncode($"Bearer {AccessToken}") }, { "context", HttpUtility.UrlEncode(_contextId) } }; _streamingConnection = new Connection(StreamingConnectionUrl, queryStringData) { // Use the shared cookie container to ensure stickiness CookieContainer = _cookieContainer }; _streamingConnection.StateChanged += Connection_StateChanged; _streamingConnection.Received += Connection_Received; _streamingConnection.Error += Connection_Error; return(_streamingConnection.Start(transport)); }
/// <summary> /// Start the hub connection - populate FunctionNamesToFullNames first /// </summary> /// <returns></returns> public async Task StartAsync() { hubConnection?.Stop(); hubConnection?.Dispose(); hubConnection = new HubConnection(ConnectionUrl); hubConnection.Closed += SocketClosed; hubProxy = hubConnection.CreateHubProxy(HubName); foreach (string key in FunctionNamesToFullNames.Keys) { hubProxy.On(key, (string data) => HandleResponse(key, data)); } DefaultHttpClient client = new DefaultHttpClient(); var autoTransport = new AutoTransport(client, new IClientTransport[] { new WebsocketCustomTransport(client) }); hubConnection.TransportConnectTimeout = hubConnection.DeadlockErrorTimeout = TimeSpan.FromSeconds(10.0); await hubConnection.Start(autoTransport); HubListener[] listeners; lock (this.listeners) { listeners = this.listeners.Values.ToArray(); } foreach (var listener in listeners) { await hubProxy.Invoke <bool>(listener.FunctionFullName, listener.Param); } }
public async Task StartAsync() { DefaultHttpClient client = new DefaultHttpClient(); var autoTransport = new AutoTransport(client, new IClientTransport[] { new WebsocketCustomTransport(client) }); hubConnection.TransportConnectTimeout = hubConnection.DeadlockErrorTimeout = TimeSpan.FromSeconds(10.0); await hubConnection.Start(autoTransport); }
public override Transport Deserialize(string data) { AutoTransport transport = new AutoTransport(); byte[] bdata = Convert.FromBase64String(data); MemoryStream ms1 = new MemoryStream(bdata); using (BsonReader reader = new BsonReader(ms1)) { JsonSerializer deserializer = new JsonSerializer(); transport = deserializer.Deserialize <AutoTransport>(reader); } return(transport); }
public async Task Connect(BittrexFeedConnectionConfiguration configuration) { DefaultHttpClientEx httpClient = new DefaultHttpClientEx(); AutoTransport autoTransport = null; if (configuration != null) { if (configuration.Connection != null) { var transports = new IClientTransport[] { new WebSocketSharpTransport(httpClient), new LongPollingTransport(httpClient) }; autoTransport = new AutoTransport(httpClient, transports); _connection.CookieContainer = configuration.Connection.CookieContainer; if (configuration.Connection.Headers != null) { foreach (var header in configuration.Connection.Headers) { _connection.Headers[header.Key] = header.Value; } } _connection.TransportConnectTimeout = new TimeSpan(0, 0, 10); } if (!string.IsNullOrEmpty(configuration.AccessToken)) { var aspNetApplicationCookie = new Cookie(BittrexConstants.accessTokenCookieName, configuration.AccessToken, "/", ".bittrex.com"); _connection.CookieContainer.Add(_feedUri, aspNetApplicationCookie); } } if (autoTransport == null) { autoTransport = new AutoTransport(httpClient); } await _connection.Start(autoTransport); }
public override async Task <bool> Connect() { var client = new DefaultHttpClient(); var autoTransport = new AutoTransport(client, new IClientTransport[] { new WebsocketCustomTransport(log, client) }); connection.TransportConnectTimeout = new TimeSpan(0, 0, 10); try { await connection.Start(autoTransport).ConfigureAwait(false); return(true); } catch (Exception) { return(false); } }
private static Task Do() { string url = "http://192.168.70.118:1980"; var connection = new HubConnection(url); IHubProxy hub = connection.CreateHubProxy("echo"); var httpClient = new DefaultHttpClient(); var transport = new AutoTransport( httpClient, new IClientTransport[] { //new ServerSentEventsTransport(httpClient), new LongPollingTransport(httpClient) } ); //connection.Error += // error => ConsoleColor.Red.AsColorFor(() => Console.WriteLine("Error from connection: {0}", error)); connection.Closed += () => { Console.WriteLine("Closed"); //if (!connection.EnsureReconnecting()) //{ // Task.Delay(TimeSpan.FromSeconds(30)).ContinueWith(t => connection.Start().Wait()); //} if (!connection.EnsureReconnecting()) { Task.Factory.StartNew(() => Thread.Sleep(TimeSpan.FromSeconds(30))) .ContinueWith(t => connection.Start().Wait()); } }; connection.ConnectionSlow += () => Console.WriteLine("ConnectionSolw!"); connection.Received += data => Console.WriteLine(string.Format("Received:{0}", data)); connection.Reconnected += () => Console.WriteLine("Reconnected!"); connection.StateChanged += state => Console.WriteLine("StateChanged:From {0} to {1}", state.OldState, state.NewState); return(connection.Start(transport).ContinueWith(_ => { Console.WriteLine("Connected, transport is :{0}", connection.Transport.Name); return hub; })); }
public void CancelledTaskHandledinAutoTransport() { var tcs = new TaskCompletionSource <IResponse>(); tcs.TrySetCanceled(); var transport = new Mock <IClientTransport>(); transport.Setup(t => t.Start(It.IsAny <IConnection>(), It.IsAny <string>(), CancellationToken.None)) .Returns(tcs.Task); var transports = new List <IClientTransport>(); transports.Add(transport.Object); var autoTransport = new AutoTransport(new DefaultHttpClient(), transports); var task = autoTransport.Start(new Connection("http://foo"), string.Empty, CancellationToken.None); Assert.IsType(typeof(OperationCanceledException), task.Exception.InnerException); }
public async Task CancelledTaskHandledinAutoTransport() { var tcs = new TaskCompletionSource <IResponse>(); tcs.TrySetCanceled(); var transport = new Mock <IClientTransport>(); transport.Setup(t => t.Start(It.IsAny <IConnection>(), It.IsAny <string>(), CancellationToken.None)) .Returns(tcs.Task); var transports = new List <IClientTransport>(); transports.Add(transport.Object); var autoTransport = new AutoTransport(new DefaultHttpClient(), transports); await Assert.ThrowsAsync <OperationCanceledException>( () => autoTransport.Start(new Connection("http://foo"), string.Empty, CancellationToken.None)); }
public async Task WebSocketsTriedByAutoTransportIfNegotiateIsNotCalled() { var fallbackTransport = new Mock <IClientTransport>(); var webSocketTransport = new Mock <IClientTransport>(); webSocketTransport.Setup(m => m.Name).Returns(new WebSocketTransport().Name); var transports = new List <IClientTransport>() { webSocketTransport.Object, fallbackTransport.Object, }; var autoTransport = new AutoTransport(null, transports); await autoTransport.Start(null, string.Empty, CancellationToken.None).OrTimeout(); webSocketTransport.Verify(m => m.Start(null, string.Empty, CancellationToken.None), Times.Once()); fallbackTransport.Verify(m => m.Start(null, string.Empty, CancellationToken.None), Times.Never()); }
public Task CreateStreamingConnection(string contextId) { var transport = new AutoTransport(new DefaultHttpClient()); var queryStringData = new Dictionary <string, string> { { "authorization", HttpUtility.UrlEncode($"Bearer {Config.ApiKey}") }, { "context", HttpUtility.UrlEncode(contextId) } }; _streamingConnection = new Connection(StreamingConnectionUrl, queryStringData) { CookieContainer = Helper.CookieContainer }; _streamingConnection.StateChanged += Connection_StateChanged; _streamingConnection.Received += Connection_Received; _streamingConnection.Error += Connection_Error; return(_streamingConnection.Start(transport)); }
public void FallbackToLongPollingIIS() { using (ITestHost host = CreateHost(HostType.IISExpress)) { // Reduce transportConnectionTimeout to 5 seconds host.Initialize(transportConnectTimeout: 5); var connection = CreateConnection(host, "/fall-back"); using (connection) { var tcs = new TaskCompletionSource <object>(); connection.StateChanged += change => { if (change.NewState == ConnectionState.Reconnecting) { tcs.TrySetException(new Exception("The connection should not be reconnecting")); } }; var client = new DefaultHttpClient(); var transports = new IClientTransport[] { new ServerSentEventsTransport(client), new LongPollingTransport(client) }; var transport = new AutoTransport(client, transports); connection.Start(transport).Wait(); Assert.Equal(connection.Transport.Name, "longPolling"); Assert.False(tcs.Task.Wait(TimeSpan.FromSeconds(5))); } } }
/// <summary> /// Start the hub connection - populate FunctionNamesToFullNames first /// </summary> /// <returns></returns> public async Task StartAsync() { // stop any previous hub connection hubConnection?.Stop(); hubConnection?.Dispose(); // make a new hub connection hubConnection = new HubConnection(ConnectionUrl, false); hubConnection.Closed += SocketClosed; #if DEBUG //hubConnection.TraceLevel = TraceLevels.All; //hubConnection.TraceWriter = Console.Out; #endif hubProxy = hubConnection.CreateHubProxy(HubName); if (hubProxy == null) { throw new APIException("CreateHubProxy - proxy is null, this should never happen"); } // assign callbacks for events foreach (string key in FunctionNamesToFullNames.Keys) { hubProxy.On(key, async(string data) => await HandleResponse(key, data)); } // create a custom transport, the default transport is really buggy DefaultHttpClient client = new DefaultHttpClient(); WebsocketCustomTransport customTransport = new WebsocketCustomTransport(client); var autoTransport = new AutoTransport(client, new IClientTransport[] { customTransport }); hubConnection.TransportConnectTimeout = hubConnection.DeadlockErrorTimeout = TimeSpan.FromSeconds(10.0); // setup connect event customTransport.WebSocket.Connected += async(ws) => { SignalrSocketConnection[] socketsCopy; lock (sockets) { socketsCopy = sockets.ToArray(); } foreach (SignalrSocketConnection socket in socketsCopy) { await socket.InvokeConnected(); } }; // setup disconnect event customTransport.WebSocket.Disconnected += async(ws) => { try { SignalrSocketConnection[] socketsCopy; lock (sockets) { socketsCopy = sockets.ToArray(); } foreach (SignalrSocketConnection socket in socketsCopy) { await socket.InvokeDisconnected(); } } catch (Exception ex) { Logger.Info(ex.ToString()); } // start a task to tear down the hub connection await Task.Run(() => { try { // tear down the hub connection, we must re-create it whenever a web socket disconnects hubConnection?.Dispose(); } catch (Exception ex) { Logger.Info(ex.ToString()); } }); }; await hubConnection.Start(autoTransport); // get list of listeners quickly to limit lock HubListener[] listeners; lock (this.listeners) { listeners = this.listeners.Values.ToArray(); } // re-call the end point to enable messages foreach (var listener in listeners) { foreach (object[] p in listener.Param) { await hubProxy.Invoke <bool>(listener.FunctionFullName, p); } } }
/// <summary> /// Start the hub connection - populate FunctionNamesToFullNames first /// </summary> /// <returns></returns> public async Task StartAsync() { // stop any previous hub connection hubConnection?.Stop(); hubConnection?.Dispose(); // make a new hub connection hubConnection = new HubConnection(ConnectionUrl, false); hubConnection.Closed += SocketClosed; ///TODO:正式发布注释代码 #region 测试 输入signalr日志 hubConnection.TraceLevel = TraceLevels.All; hubConnection.TraceWriter = Console.Out; #endregion hubConnection.StateChanged += StateChange; hubConnection.ConnectionSlow += ConnectionSlow; hubConnection.Error += Error; //hubConnection.Received += Received; hubProxy = hubConnection.CreateHubProxy(HubName); // assign callbacks for events foreach (string key in FunctionNamesToFullNames.Keys) { hubProxy.On(key, (string data) => HandleResponse(key, data)); } // create a custom transport, the default transport is really buggy DefaultHttpClient client = new DefaultHttpClient(); customTransport = new WebsocketCustomTransport(client); var autoTransport = new AutoTransport(client, new IClientTransport[] { customTransport }); hubConnection.TransportConnectTimeout = hubConnection.DeadlockErrorTimeout = TimeSpan.FromSeconds(10.0); // setup connect event customTransport.WebSocket.Connected += (ws) => { lock (sockets) { foreach (IWebSocket socket in sockets) { (socket as SignalrSocketConnection).InvokeConnected(); } } }; // setup disconnect event customTransport.WebSocket.Disconnected += (ws) => { lock (sockets) { foreach (IWebSocket socket in sockets) { (socket as SignalrSocketConnection).InvokeDisconnected(); } } // start a task to tear down the hub connection Task.Run(() => { try { // tear down the hub connection, we must re-create it whenever a web socket disconnects hubConnection?.Dispose(); } catch (Exception ex) { Console.WriteLine($"hubConnection dispose error: {ex.Message}"); } }); }; await hubConnection.Start(autoTransport); // get list of listeners quickly to limit lock HubListener[] listeners; lock (this.listeners) { listeners = this.listeners.Values.ToArray(); } // re-call the end point to enable messages foreach (var listener in listeners) { foreach (string[] p in listener.Param) { await hubProxy.Invoke <bool>(listener.FunctionFullName, p); } } }
private void Connect() { var transport = new AutoTransport(); try { LogToUI(":: Starting Connection"); Task task = _connection.Start(transport).ContinueWith((t) => { LogToUI (":: Waiting for server..."); var joinResult = _chat.Invoke<bool>("Join"); joinResult.Wait(); if (joinResult.Status == TaskStatus.Faulted) { LogToUI (":: Failed to Join to Server"); } else if (joinResult.Result == true) { LogToUI(":: Connected, already logged in."); } else { LogToUI (":: Connected, type /nick [username] [password] to log in"); } }); } catch (Exception ex) { LogToUI("Exception when connecting: {0}", ex.Message); LogText("Exception when connecting: {0}", ex.ToString()); } }