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