public void Setup()
{
factory = A.Fake <IConnectionFactory>();
fakeHttp = A.Fake <ISimpleHttpGetRequest>();
fakeWebSocket = A.Fake <IWebSocket>();
heartBeatSignaler = A.Fake <IHeartBeatSignaler>();
A.CallTo(() => factory.CreateHttpRequest(A <string> ._)).Returns(fakeHttp);
A.CallTo(() => fakeHttp.Execute()).ReturnsLazily(() => handshakeResponse);
A.CallTo(() => factory.CreateWebSocket(A <string> ._)).Returns(fakeWebSocket);
A.CallTo(() => fakeWebSocket.Connected).ReturnsLazily(() => isConnected);
A.CallTo(() => fakeWebSocket.Open()).Invokes(() =>
{
isConnected = true;
fakeWebSocket.Opened += Raise.With(fakeWebSocket, EventArgs.Empty).Now;
});
A.CallTo(() => fakeWebSocket.Close()).Invokes(() =>
{
isConnected = false;
fakeWebSocket.Closed += Raise.With(fakeWebSocket, EventArgs.Empty).Now;
});
io = new SocketIOClient(factory, heartBeatSignaler);
socket = io.Connect("http://localhost:3000");
}
public Namespace Connect(string serverUrl, string resource = "socket.io")
{
if (Connected || Connecting || Reconnecting)
return Of(DefaultNamespace);
m_heartBeatSignaler.Stop();
ServerUrl = serverUrl;
var uri = new Uri(serverUrl);
var handshakeResult = DoHandshake(uri, resource);
if (handshakeResult == HandshakeResult.Success)
{
EmitLocally("connecting", "websocket");
var socketUri = string.Format("{0}://{1}:{2}/{4}/1/websocket/{3}",
uri.Scheme == Uri.UriSchemeHttps ? "wss" : "ws", uri.Host, uri.Port, Id, resource);
m_socket = m_connectionFactory.CreateWebSocket(socketUri);
m_socket.AllowUnstrustedCertificate = AllowUnstrustedCertificate;
m_socket.Opened += OnOpened;
m_socket.MessageReceived += OnMessageReceived;
m_socket.Error += OnError;
m_socket.Closed += OnClosed;
m_heartBeatSignaler.Start(m_socket, HeartbeatTimeout);
m_socket.Open();
}
return Of(DefaultNamespace);
}
/// <summary>
/// Begins a Real Time Messaging API session and connects via a websocket.
/// Will reconnect automatically.
/// </summary>
/// <param name="manualPresenceSubscription">Only deliver presence events when requested by subscription.</param>
/// <param name="batchPresenceAware">Group presence change notices in <see cref="PresenceChange"/> events when possible.</param>
/// <param name="cancellationToken"></param>
public async Task <ConnectResponse> Connect(bool batchPresenceAware = false, bool manualPresenceSubscription = false, CancellationToken?cancellationToken = null)
{
if (Connected)
{
throw new InvalidOperationException("Already connecting or connected");
}
var connectResponse = await _client.Rtm.Connect(manualPresenceSubscription, batchPresenceAware, cancellationToken).ConfigureAwait(false);
_webSocket?.Dispose();
_webSocket = _webSocketFactory.Create(connectResponse.Url);
var openedTask = _webSocket.Opened
.Merge(_webSocket.Errors.SelectMany(Observable.Throw <Unit>))
.FirstAsync()
.ToTask(cancellationToken);
_webSocket.Open();
await openedTask.ConfigureAwait(false);
_eventSubscription?.Dispose();
_eventSubscription = _webSocket.Messages
.Select(m => JsonConvert.DeserializeObject <Event>(m, _jsonSettings.SerializerSettings))
.Subscribe(_rawEvents);
_reconnection?.Dispose();
_reconnection = _webSocket.Closed
.SelectMany(_ => Observable.FromAsync(() => Connect(batchPresenceAware, manualPresenceSubscription, cancellationToken), _scheduler)
.RetryWithDelay(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5), TimeSpan.FromMinutes(5), _scheduler))
.Subscribe();
return(connectResponse);
}
public void Setup()
{
factory = A.Fake<IConnectionFactory>();
fakeHttp = A.Fake<ISimpleHttpGetRequest>();
fakeWebSocket = A.Fake<IWebSocket>();
heartBeatSignaler = A.Fake<IHeartBeatSignaler>();
A.CallTo(() => factory.CreateHttpRequest(A<string>._)).Returns(fakeHttp);
A.CallTo(() => fakeHttp.Execute()).ReturnsLazily(() => handshakeResponse);
A.CallTo(() => factory.CreateWebSocket(A<string>._)).Returns(fakeWebSocket);
A.CallTo(() => fakeWebSocket.Connected).ReturnsLazily(() => isConnected);
A.CallTo(() => fakeWebSocket.Open()).Invokes(() =>
{
isConnected = true;
fakeWebSocket.Opened += Raise.With(fakeWebSocket, EventArgs.Empty).Now;
});
A.CallTo(() => fakeWebSocket.Close()).Invokes(() =>
{
isConnected = false;
fakeWebSocket.Closed += Raise.With(fakeWebSocket, EventArgs.Empty).Now;
});
io = new SocketIOClient(factory, heartBeatSignaler);
socket = io.Connect("http://localhost:3000");
}
public void Ssl_trusted_by_us()
{
// arrange
SetupOurTrustedCertToBe("trusted.ca.crt");
SetupCerts(keyFile: "trusted.key",
certFile: "trusted.crt");
_websocketProcess.StartThinServer();
_socket.MessageReceived += SocketMessageReceived;
// act
_socket.Opened += SocketOpened;
_socket.Open();
// assert
var withinTimeout = _messageReceivedTask.Task.Wait(2.Seconds());
if (!withinTimeout)
{
Assert.Fail("Timed out waiting for response from web socket!");
}
_messageReceivedTask
.Task
.Result
.Should()
.Be("Received your message hi there");
}
public void Open()
{
if (websocket != null)
{
websocket.Open();
}
}
public void Connect()
{
string url;
if (this.encrypted || this.secure)
{
url = "wss://" + Pusher.host + ":" + Pusher.wss_port + this.path;
}
else
{
url = "ws://" + Pusher.host + ":" + Pusher.ws_port + this.path;
}
Pusher.allow_reconnect = true;
Pusher.Log("Pusher : connecting : " + url);
var self = this;
IWebSocket ws = CreateWebSocket(url);
// Timeout for the connection to handle silently hanging connections
// Increase the timeout after each retry in case of extreme latencies
int interval = Pusher.connection_timeout + (this.retry_counter * 1000);
var timerRef = new TimerRef();
timerRef.Ref = new Timer(delegate(object state)
{
Pusher.Log("Pusher : connection timeout after " + interval + "ms");
ws.Close();
try { timerRef.Ref.Dispose(); }
catch { }
}, null, interval, interval);
ws.OnData += (sender, e) => OnMessage(e);
ws.OnClose += (sender, e) =>
{
try { timerRef.Ref.Dispose(); }
catch { }
OnClose();
};
ws.OnOpen += (sender, e) =>
{
try { timerRef.Ref.Dispose(); }
catch { }
OnOpen();
};
this.connection = ws;
ws.Open();
}
public Namespace Connect(string serverUrl, string resource = "socket.io")
{
if (Connected || Connecting || Reconnecting)
{
return(Of(DefaultNamespace));
}
m_heartBeatSignaler.Stop();
ServerUrl = serverUrl;
var uri = new Uri(serverUrl);
var handshakeResult = DoHandshake(uri, resource);
if (handshakeResult == HandshakeResult.Success)
{
EmitLocally("connecting", "websocket");
var socketUri = string.Format("{0}://{1}:{2}/{4}/1/websocket/{3}",
uri.Scheme == Uri.UriSchemeHttps ? "wss" : "ws", uri.Host, uri.Port, Id, resource);
m_socket = m_connectionFactory.CreateWebSocket(socketUri);
m_socket.AllowUnstrustedCertificate = AllowUnstrustedCertificate;
m_socket.Opened += OnOpened;
m_socket.MessageReceived += OnMessageReceived;
m_socket.Error += OnError;
m_socket.Closed += OnClosed;
m_heartBeatSignaler.Start(m_socket, HeartbeatTimeout);
m_socket.Open();
}
return(Of(DefaultNamespace));
}
public void MakeConnection(HandshakeResult result, Uri uri, string resource)
{
if (result != HandshakeResult.Success)
{
OnConnectionFailed();
return;
}
EmitLocally("connecting", "websocket");
var socketUri = string.Format("{0}://{1}:{2}/{4}/1/websocket/{3}",
uri.Scheme == Uri.UriSchemeHttps ? "wss" : "ws", uri.Host, uri.Port, Id,
resource);
m_socket = m_connectionFactory.CreateWebSocket(socketUri);
m_socket.AllowUnstrustedCertificate = AllowUnstrustedCertificate;
m_socket.Opened += OnOpened;
m_socket.MessageReceived += OnMessageReceived;
m_socket.Error += OnError;
m_socket.Closed += OnClosed;
m_heartBeatSignaler.Start(m_socket, HeartbeatTimeout);
m_socket.Open();
OnConnectionEstablished(Of(DefaultNamespace));
}
