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 string GetId(IWebSocket socket)
{
lock (_syncRoot)
{
return(_sockets.FirstOrDefault(p => p.Value == socket).Key);
}
}
public IWebSocketHandler CreateWebSocketHandler(HttpRequest request, IWebSocket webSocket)
{
ISocketProvider socketProvider = GetSocketProvider(request.Uri);
ISocket socket = socketProvider.CreateSocket(webSocket);
return(new WebSocketHandler(socketProvider, socket));
}
/// <summary>
/// Constructor for brokerage
/// </summary>
/// <param name="wssUrl">websockets url</param>
/// <param name="websocket">instance of websockets client</param>
/// <param name="restClient">instance of rest client</param>
/// <param name="apiKey">api key</param>
/// <param name="apiSecret">api secret</param>
/// <param name="passPhrase">pass phrase</param>
/// <param name="algorithm">the algorithm instance is required to retreive account type</param>
/// <param name="priceProvider">The price provider for missing FX conversion rates</param>
public GDAXBrokerage(string wssUrl, IWebSocket websocket, IRestClient restClient, string apiKey, string apiSecret, string passPhrase, IAlgorithm algorithm,
IPriceProvider priceProvider)
: base(wssUrl, websocket, restClient, apiKey, apiSecret, Market.GDAX, "GDAX")
{
FillSplit = new ConcurrentDictionary <long, GDAXFill>();
_passPhrase = passPhrase;
_algorithm = algorithm;
_priceProvider = priceProvider;
WebSocket.Open += (sender, args) =>
{
var tickers = new[]
{
"LTCUSD", "LTCEUR", "LTCBTC",
"BTCUSD", "BTCEUR", "BTCGBP",
"ETHBTC", "ETHUSD", "ETHEUR",
"BCHBTC", "BCHUSD", "BCHEUR",
"XRPUSD", "XRPEUR", "XRPBTC",
"EOSUSD", "EOSEUR", "EOSBTC",
"XLMUSD", "XLMEUR", "XLMBTC",
"ETCUSD", "ETCEUR", "ETCBTC",
"ZRXUSD", "ZRXEUR", "ZRXBTC",
};
Subscribe(tickers.Select(ticker => Symbol.Create(ticker, SecurityType.Crypto, Market.GDAX)));
};
_isDataQueueHandler = this is GDAXDataQueueHandler;
}
public async Task ShouldEmitCloseEvents()
{
var socketClosedTcs = new TaskCompletionSource <bool>();
var log = new List <string>();
IWebSocket webSocket = null;
Page.WebSocket += (_, e) =>
{
log.Add($"open<{e.Url}>");
webSocket = e;
webSocket.Close += (_, _) =>
{
log.Add("close");
socketClosedTcs.TrySetResult(true);
};
};
await Page.EvaluateAsync(@"port => {
const ws = new WebSocket('ws://localhost:' + port + '/ws');
ws.addEventListener('open', () => ws.close());
}", Server.Port);
await socketClosedTcs.Task;
Assert.AreEqual($"open<ws://localhost:{Server.Port}/ws>:close", string.Join(":", log));
Assert.True(webSocket.IsClosed);
}
private async void _CommentSessionWebSocket_Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
using (var releaser = await _CommentSessionLock.LockAsync())
{
Debug.WriteLine($"<CommentSession Closed> {args.Code}: {args.Reason}");
}
}
/// <summary>
/// Creates an instance of a websockets brokerage
/// </summary>
/// <param name="wssUrl">Websockets base url</param>
/// <param name="websocket">Websocket client instance</param>
/// <param name="restClient">Rest client instance</param>
/// <param name="apiKey">Brokerage api auth key</param>
/// <param name="apiSecret">Brokerage api auth secret</param>
/// <param name="websocketMaximumIdle">The maximum amount of time the socket can go idle before triggering a reconnect</param>
/// <param name="name">Name of brokerage</param>
protected BaseWebsocketsBrokerage(string wssUrl, IWebSocket websocket, IRestClient restClient, string apiKey, string apiSecret, TimeSpan websocketMaximumIdle, string name) : base(name)
{
JsonSettings = new JsonSerializerSettings {
FloatParseHandling = FloatParseHandling.Decimal
};
CachedOrderIDs = new ConcurrentDictionary <int, Orders.Order>();
_connectionHandler = new DefaultConnectionHandler {
MaximumIdleTimeSpan = websocketMaximumIdle
};
WebSocket = websocket;
WebSocket.Initialize(wssUrl);
WebSocket.Message += (sender, message) =>
{
OnMessage(sender, message);
_connectionHandler.KeepAlive(LastHeartbeatUtcTime);
};
_connectionHandler.Initialize(Guid.NewGuid().ToString());
_connectionHandler.ReconnectRequested += (sender, args) =>
{
Reconnect();
};
RestClient = restClient;
ApiSecret = apiSecret;
ApiKey = apiKey;
}
public void Start(IWebSocket socket, int interval)
{
m_socket = socket;
m_heartBeatTimer.Interval = interval;
m_heartBeatTimer.Start();
}
//The Closed event handler
private void WebSock_Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
WSLOG("WS: disconnenction detected");
_connected = false;
foreach (Queue <WSRequest> queue in _workingRequests)
{
foreach (WSRequest wsRequest in queue)
{
wsRequest.imm_close(YAPI.IO_ERROR, "Websocket connection lost with " + _hub.Host);
}
queue.Clear();
}
if (!_mustStop)
{
_hub._devListValidity = 500;
int error_delay = 100 << (_notifRetryCount > 4 ? 4 : _notifRetryCount);
_notifRetryCount++;
TimeSpan delay = TimeSpan.FromMilliseconds(error_delay);
_reconnectionTimer = ThreadPoolTimer.CreateTimer(expirationHandler, delay);
}
WSLOG("WS: disconnenction detected done");
}
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);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSocketConnection" /> class.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="remoteEndPoint">The remote end point.</param>
/// <param name="jsonSerializer">The json serializer.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="System.ArgumentNullException">socket</exception>
public WebSocketConnection(IWebSocket socket, string remoteEndPoint, IJsonSerializer jsonSerializer, ILogger logger)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
if (string.IsNullOrEmpty(remoteEndPoint))
{
throw new ArgumentNullException("remoteEndPoint");
}
if (jsonSerializer == null)
{
throw new ArgumentNullException("jsonSerializer");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_jsonSerializer = jsonSerializer;
_socket = socket;
_socket.OnReceiveDelegate = OnReceiveInternal;
RemoteEndPoint = remoteEndPoint;
_logger = logger;
}
protected void ConnectWebSocket()
{
if (string.IsNullOrEmpty(FTLSocketUri))
{
Debug.LogError("FTL SocketUri must be set");
return;
}
var customHeaders = new List <KeyValuePair <string, string> >();
if (Headers != null)
{
foreach (UnityKeyValue header in Headers)
{
customHeaders.Add(new KeyValuePair <string, string>(header.key, header.value));
}
}
#if ENABLE_WINMD_SUPPORT
Debug.Log("Using UWP Web Socket");
_ws = new WebSocketUWP();
#elif UNITY_EDITOR || ENABLE_MONO
Debug.Log("Using Mono FTL Socket");
_ws = new WebSocketMono();
#endif
if (!isAttached)
{
_ws.ConfigureWebSocket(FTLSocketUri, customHeaders);
Debug.Log("Connect FTL Socket: " + _ws.Url());
AttachHandlers();
_ws.ConnectAsync();
}
}
private void OnCloseReceived(IWebSocket sender, WebSocketClosedEventArgs args)
{
var recvResult = new WebSocketReceiveResult(0, WebSocketMessageType.Close, true, (WebSocketCloseStatus)args.Code,
args.Reason);
_closeWebSocketReceiveResultTcs.TrySetResult(recvResult);
}
private void Connection_Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
MessageWebSocket webSocket = Interlocked.Exchange(ref _connection, null);
webSocket?.Dispose();
ConnectionClosed = true;
}
public void AddSocket(IWebSocket socket)
{
lock (_syncRoot)
{
_sockets[socket.Id] = socket;
}
}
public MessageProvider2(IWebSocket webSocket, ILogger logger)
{
_webSocket = webSocket;
_logger = logger;
webSocket.Opened += WebSocket_Opened;
webSocket.Received += WebSocket_Received;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSocketConnection" /> class.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="remoteEndPoint">The remote end point.</param>
/// <param name="jsonSerializer">The json serializer.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="System.ArgumentNullException">socket</exception>
public WebSocketConnection(IWebSocket socket, string remoteEndPoint, IJsonSerializer jsonSerializer, ILogger logger, IMemoryStreamFactory memoryStreamProvider, ITextEncoding textEncoding)
{
if (socket == null)
{
throw new ArgumentNullException("socket");
}
if (string.IsNullOrEmpty(remoteEndPoint))
{
throw new ArgumentNullException("remoteEndPoint");
}
if (jsonSerializer == null)
{
throw new ArgumentNullException("jsonSerializer");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
Id = Guid.NewGuid();
_jsonSerializer = jsonSerializer;
_socket = socket;
_socket.OnReceiveBytes = OnReceiveInternal;
_socket.OnReceive = OnReceiveInternal;
RemoteEndPoint = remoteEndPoint;
_logger = logger;
_memoryStreamProvider = memoryStreamProvider;
_textEncoding = textEncoding;
socket.Closed += socket_Closed;
}
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));
}
/// <summary>
/// Constructor for brokerage
/// </summary>
/// <param name="websocket">instance of websockets client</param>
/// <param name="restClient">instance of rest client</param>
/// <param name="apiKey">api key</param>
/// <param name="apiSecret">api secret</param>
/// <param name="algorithm">the algorithm instance is required to retrieve account type</param>
/// <param name="priceProvider">The price provider for missing FX conversion rates</param>
/// <param name="aggregator">consolidate ticks</param>
/// <param name="job">The live job packet</param>
public BitfinexBrokerage(IWebSocket websocket, IRestClient restClient, string apiKey, string apiSecret, IAlgorithm algorithm, IPriceProvider priceProvider, IDataAggregator aggregator, LiveNodePacket job)
: base(WebSocketUrl, websocket, restClient, apiKey, apiSecret, "Bitfinex")
{
_job = job;
SubscriptionManager = new BrokerageMultiWebSocketSubscriptionManager(
WebSocketUrl,
MaximumSymbolsPerConnection,
0,
null,
() => new BitfinexWebSocketWrapper(null),
Subscribe,
Unsubscribe,
OnDataMessage,
TimeSpan.Zero,
_connectionRateLimiter);
_symbolPropertiesDatabase = SymbolPropertiesDatabase.FromDataFolder();
_algorithm = algorithm;
_aggregator = aggregator;
// load currency map
using (var wc = new WebClient())
{
var json = wc.DownloadString("https://api-pub.bitfinex.com/v2/conf/pub:map:currency:sym");
var rows = JsonConvert.DeserializeObject <List <List <List <string> > > >(json)[0];
_currencyMap = rows
.ToDictionary(row => row[0], row => row[1].ToUpperInvariant());
}
WebSocket.Open += (sender, args) =>
{
SubscribeAuth();
};
}
private Task WebSocketOnMessageReceived(IWebSocket socket, byte[] data)
{
string dataText = data.ToStringFromUTF8();
ProcessResponse(connection, dataText);
return(Task.CompletedTask);
}
/// <summary>
/// Handler for connection end.
/// Associated with Websocket.
/// </summary>
private void ConnectionEnded(IWebSocket sender, WebSocketClosedEventArgs args)
{
this.IsConnected = false;
this.WebSocket.Dispose();
this.WebSocket = null;
this.ConnectionEndedUIHandler?.Invoke(this, EventArgs.Empty);
}
public async Task ShouldRejectWaitForEventOnSocketClose()
{
var frameReceivedTcs = new TaskCompletionSource <bool>();
IWebSocket ws = null;
Page.WebSocket += (_, e) =>
{
ws = e.WebSocket;
e.WebSocket.FrameReceived += (_, e) => frameReceivedTcs.TrySetResult(true);
};
await TaskUtils.WhenAll(
frameReceivedTcs.Task,
Page.EvaluateAsync(@"port => {
window.ws = new WebSocket('ws://localhost:' + port + '/ws');
}", TestConstants.Port));
await frameReceivedTcs.Task;
var frameSentTask = ws.WaitForEventAsync(WebSocketEvent.FrameSent);
await Page.EvaluateAsync("window.ws.close()");
var exception = await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => frameSentTask);
Assert.Contains("Socket closed", exception.Message);
}
private void Connect(IWebSocket webSocket)
{
var connectedEvent = new ManualResetEvent(false);
EventHandler onOpenAction = (s, e) =>
{
connectedEvent.Set();
};
webSocket.Open += onOpenAction;
try
{
webSocket.Connect();
if (!connectedEvent.WaitOne(ConnectionTimeout))
{
throw new Exception("BitfinexSubscriptionManager.Connect(): WebSocket connection timeout.");
}
}
finally
{
webSocket.Open -= onOpenAction;
connectedEvent.DisposeSafely();
}
}
/// <summary>
/// Initialize the instance of this class
/// </summary>
/// <param name="wssUrl">The web socket base url</param>
/// <param name="websocket">instance of websockets client</param>
/// <param name="restClient">instance of rest client</param>
/// <param name="apiKey">api key</param>
/// <param name="apiSecret">api secret</param>
/// <param name="passPhrase">pass phrase</param>
/// <param name="algorithm">the algorithm instance is required to retrieve account type</param>
/// <param name="priceProvider">The price provider for missing FX conversion rates</param>
/// <param name="aggregator">the aggregator for consolidating ticks</param>
/// <param name="job">The live job packet</param>
protected void Initialize(string wssUrl, IWebSocket websocket, IRestClient restClient, string apiKey, string apiSecret,
string passPhrase, IAlgorithm algorithm, IPriceProvider priceProvider, IDataAggregator aggregator, LiveNodePacket job)
{
if (IsInitialized)
{
return;
}
base.Initialize(wssUrl, websocket, restClient, apiKey, apiSecret);
_job = job;
FillSplit = new ConcurrentDictionary <long, GDAXFill>();
_passPhrase = passPhrase;
_algorithm = algorithm;
_priceProvider = priceProvider;
_aggregator = aggregator;
_isDataQueueHandler = this is GDAXDataQueueHandler;
_fillMonitorTask = Task.Factory.StartNew(FillMonitorAction, _ctsFillMonitor.Token);
var subscriptionManager = new EventBasedDataQueueHandlerSubscriptionManager();
subscriptionManager.SubscribeImpl += (s, t) =>
{
Subscribe(s);
return(true);
};
subscriptionManager.UnsubscribeImpl += (s, t) => Unsubscribe(s);
SubscriptionManager = subscriptionManager;
}
public override Task ProcessRequest(ITransportConnection connection)
{
return(_context.Request.AcceptWebSocketRequest(socket =>
{
_socket = socket;
socket.OnClose = clean =>
{
// If we performed a clean disconnect then we go through the normal disconnect routine. However,
// If we performed an unclean disconnect we want to mark the connection as "not alive" and let the
// HeartBeat clean it up. This is to maintain consistency across the transports.
if (clean)
{
OnDisconnect();
}
_isAlive = false;
};
socket.OnMessage = message =>
{
OnReceiving(message);
if (Received != null)
{
Received(message).Catch();
}
};
return ProcessRequestCore(connection);
}));
}
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 override Task ProcessRequest(ITransportConnection connection)
{
return _context.Request.AcceptWebSocketRequest(socket =>
{
_socket = socket;
socket.OnClose = clean =>
{
// If we performed a clean disconnect then we go through the normal disconnect routine. However,
// If we performed an unclean disconnect we want to mark the connection as "not alive" and let the
// HeartBeat clean it up. This is to maintain consistency across the transports.
if (clean)
{
OnDisconnect();
}
_isAlive = false;
};
socket.OnMessage = message =>
{
OnReceiving(message);
if (Received != null)
{
Received(message).Catch();
}
};
return ProcessRequestCore(connection);
});
}
internal WebSocketContext(
IHttpContextImpl httpContext,
string webSocketVersion,
IEnumerable <string> requestedProtocols,
string?acceptedProtocol,
IWebSocket webSocket,
CancellationToken cancellationToken)
{
Id = UniqueIdGenerator.GetNext();
CancellationToken = cancellationToken;
HttpContextId = httpContext.Id;
Session = httpContext.Session;
Items = httpContext.Items;
LocalEndPoint = httpContext.LocalEndPoint;
RemoteEndPoint = httpContext.RemoteEndPoint;
RequestUri = httpContext.Request.Url;
Headers = httpContext.Request.Headers;
Origin = Headers[HttpHeaderNames.Origin];
RequestedProtocols = requestedProtocols;
AcceptedProtocol = acceptedProtocol;
WebSocketVersion = webSocketVersion;
Cookies = httpContext.Request.Cookies;
User = httpContext.User;
IsAuthenticated = httpContext.Request.IsAuthenticated;
IsLocal = httpContext.Request.IsLocal;
IsSecureConnection = httpContext.Request.IsSecureConnection;
WebSocket = webSocket;
}
protected virtual async Task <string[]> AddMarketSymbolsToChannel(IWebSocket socket, string channelFormat, string[] marketSymbols)
{
if (marketSymbols == null || marketSymbols.Length == 0)
{
marketSymbols = (await GetMarketSymbolsAsync()).ToArray();
}
var spotSymbols = marketSymbols.Where(ms => ms.Split('-').Length == 2);
var futureSymbols = marketSymbols.Where(
ms => ms.Split('-').Length == 3 && int.TryParse(ms.Split('-')[2], out int i));
var swapSymbols = marketSymbols.Where(
ms => ms.Split('-').Length == 3 && ms.Split('-')[2] == "SWAP");
await sendMessageAsync("spot", spotSymbols);
await sendMessageAsync("futures", futureSymbols);
await sendMessageAsync("swap", swapSymbols);
async Task sendMessageAsync(string category, IEnumerable <string> symbolsToSend)
{
var channels = symbolsToSend
.Select(marketSymbol => string.Format($"{category}{channelFormat}", NormalizeMarketSymbol(marketSymbol)))
.ToArray();
await socket.SendMessageAsync(new { op = "subscribe", args = channels });
}
return(marketSymbols);
}
public async override Task InitAsync()
{
var callResult = await PerformNetworkOperation(async() =>
{
var channelId = GetChannelURI();
Debug.WriteLine("Asing for end URI: " + channelId);
var wsResult = await RestClient.GetAsync <InvokeResult <string> >(channelId);
if (wsResult.Successful)
{
var url = wsResult.Result.Result;
Debug.WriteLine(url);
_wsUri = new Uri(url);
_webSocket = SLWIOC.Create <IWebSocket>();
_webSocket.MessageReceived += _webSocket_MessageReceived;
var wsOpenResult = await _webSocket.OpenAsync(_wsUri);
if (wsOpenResult.Successful)
{
Debug.WriteLine("OPENED CHANNEL");
}
return(wsOpenResult);
}
else
{
return(wsResult.ToInvokeResult());
}
});
}
public override Task ProcessRequest(ITransportConnection connection)
{
return _context.Request.AcceptWebSocketRequest(socket =>
{
_socket = socket;
socket.OnClose = () =>
{
OnDisconnect();
_isAlive = false;
};
socket.OnMessage = message =>
{
OnReceiving(message);
if (Received != null)
{
Received(message).Catch();
}
};
return ProcessRequestCore(connection);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSocketConnection" /> class.
/// </summary>
/// <param name="socket">The socket.</param>
/// <param name="remoteEndPoint">The remote end point.</param>
/// <param name="jsonSerializer">The json serializer.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="ArgumentNullException">socket</exception>
public WebSocketConnection(IWebSocket socket, string remoteEndPoint, IJsonSerializer jsonSerializer, ILogger logger)
{
if (socket == null)
{
throw new ArgumentNullException(nameof(socket));
}
if (string.IsNullOrEmpty(remoteEndPoint))
{
throw new ArgumentNullException(nameof(remoteEndPoint));
}
if (jsonSerializer == null)
{
throw new ArgumentNullException(nameof(jsonSerializer));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
Id = Guid.NewGuid();
_jsonSerializer = jsonSerializer;
_socket = socket;
_socket.OnReceiveBytes = OnReceiveInternal;
RemoteEndPoint = remoteEndPoint;
_logger = logger;
socket.Closed += OnSocketClosed;
}
public WebSocketRsSocketClientAdapter(IWebSocket internalSocket, bool receiveOnAvailableCheck)
{
InternalSocket = internalSocket ?? throw new ArgumentNullException(nameof(internalSocket));
ReceiveOnAvailableCheck = receiveOnAvailableCheck;
InternalSocket.OnDataReceived += InternalSocketOnMessage;
}
/// <inheritdoc />
public virtual async Task Connect()
{
if (Socket != null)
{
throw new JsonRpcAlreadyConnectedException();
}
Socket?.Dispose();
RequestMgr.Reset();
ReceiveCancellationTokenSource = new CancellationTokenSource();
if (Logger?.IsEnabled(LogEventLevel.Information) ?? false)
{
Logger.Information("Connecting to {Host}", ServerUri);
}
Socket = WebSocketFactory.Create();
try
{
await Socket.ConnectAsync(ServerUri, CancellationToken.None).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger?.Error(ex, "Exception during ConnectAsync");
Socket.Dispose();
Socket = null;
throw;
}
InternalOnConnected();
}
public override Task ProcessRequest(ITransportConnection connection)
{
return(_context.Request.AcceptWebSocketRequest(socket =>
{
_socket = socket;
socket.OnClose = () =>
{
OnDisconnect();
_isAlive = false;
};
socket.OnMessage = message =>
{
OnReceiving(message);
if (Received != null)
{
Received(message).Catch();
}
};
return ProcessRequestCore(connection);
}));
}
public void TearDown()
{
isConnected = false;
factory = null;
fakeHttp = null;
fakeWebSocket = null;
socket = null;
}
void IWebSocketListener.OnOpen(IWebSocket socket, Response response)
{
var handler = Open;
if (handler != null)
{
handler(sender, new OpenEventArgs(socket, response));
}
}
public DefaultWebSocketHandler(int? maxIncomingMessageSize)
: base(maxIncomingMessageSize)
{
_webSocket = this;
_webSocket.OnClose = () => { };
_webSocket.OnError = e => { };
_webSocket.OnMessage = msg => { };
}
private void Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
System.Diagnostics.Debug.WriteLine("Closed; Code: " + args.Code + ", Reason: " + args.Reason);
if (messageWebSocket != null)
{
messageWebSocket.Dispose();
messageWebSocket = null;
}
}
void OnWebSocketClosed(IWebSocket sender, WebSocketClosedEventArgs args)
{
if (this.webSocket != null)
{
this.webSocket.Dispose();
}
Connection temp = this.connection;
if (temp != null)
{
temp.OnIoException(new ObjectDisposedException(string.Format("WebSocket closed. code={0} reason={1}", args.Code, args.Reason)));
}
}
private void StartMessages(IWebSocket webSocket)
{
// we want to ping every 2 seconds
new Timer(state =>
{
var buffer = new OkBuffer();
buffer.WriteString("Ping!", Charset.DefaultCharset());
webSocket.SendPing(buffer);
}, null, TimeSpan.Zero, TimeSpan.FromSeconds(2));
// we want to send a message every 5 seconds
new Timer(state =>
{
var body = RequestBody.Create(WebSocket.Text, "Hello World!");
webSocket.SendMessage(body);
}, null, TimeSpan.Zero, TimeSpan.FromSeconds(3));
}
public override Task ProcessRequest(ITransportConnection connection)
{
var webSocketRequest = _context.Request as IWebSocketRequest;
// Throw if the server implementation doesn't support websockets
if (webSocketRequest == null)
{
throw new InvalidOperationException(Resources.Error_WebSocketsNotSupported);
}
return webSocketRequest.AcceptWebSocketRequest(socket =>
{
_socket = socket;
socket.OnClose = clean =>
{
// If we performed a clean disconnect then we go through the normal disconnect routine. However,
// If we performed an unclean disconnect we want to mark the connection as "not alive" and let the
// HeartBeat clean it up. This is to maintain consistency across the transports.
if (clean)
{
OnDisconnect();
}
_isAlive = false;
};
socket.OnMessage = message =>
{
if (Received != null)
{
Received(message).Catch();
}
};
return ProcessRequestCore(connection);
});
}
/*public void shutdown()
{
stop.set(true);
}
}*/
private void OnClosed(IWebSocket sender, WebSocketClosedEventArgs args)
{
Debug.WriteLine("WSC disconnected...");
}
public BufferTextWriter(IWebSocket socket) :
this((data, state) => ((IWebSocket)state).SendChunk(data), socket, reuseBuffers: false, bufferSize: 1024)
{
}
// This may be triggered remotely by the server or locally by Close/Dispose()
private async void OnClosed(IWebSocket sender, WebSocketClosedEventArgs args)
{
// Dispatch the event to the UI thread so we do not need to synchronize access to messageWebSocket.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AppendOutputLine("Closed; Code: " + args.Code + ", Reason: " + args.Reason);
if (messageWebSocket == sender)
{
CloseSocket();
UpdateVisualState();
}
});
}
void mws_Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
MessageWebSocket websocket = Interlocked.Exchange(ref mws, null);
if (websocket != null)
{
websocket.Dispose();
}
//if(this.mwsState == WebSocketState.Closing)
this.OnSocketConnectionClosedEvent(this, EventArgs.Empty);
this.mwsState = WebSocketState.Closed;
}
private void OnClosed(IWebSocket sender, WebSocketClosedEventArgs args)
{
Dispose();
}
// testing/mocking
protected virtual async Task OpenWebSocket(IWebSocket webSocket, Uri uri)
{
await webSocket.ConnectAsync(uri);
}
public override Task ProcessRequest(ITransportConnection connection)
{
if (IsAbortRequest)
{
return connection.Abort(ConnectionId);
}
else
{
return AcceptWebSocketRequest(socket =>
{
_socket = socket;
socket.OnClose = _closed;
socket.OnMessage = _message;
socket.OnError = _error;
return ProcessRequestCore(connection);
});
}
}
// This may be triggered remotely by the server or locally by Close/Dispose()
private void Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
MarshalText(OutputField, "Closed; Code: " + args.Code + ", Reason: " + args.Reason + "\r\n");
if (messageWebSocket != null)
{
messageWebSocket.Dispose();
messageWebSocket = null;
}
}
// internal for testing
internal static async Task Send(IWebSocket webSocket, string data)
{
using (var messageWriter = new DataWriter(webSocket.OutputStream))
{
messageWriter.WriteString(data);
await messageWriter.StoreAsync();
messageWriter.DetachStream();
}
}
private void WebsocketClosed(IWebSocket webSocket, WebSocketClosedEventArgs eventArgs)
{
_connection.Trace(TraceLevels.Events, "WS: WebsocketClosed - Code: {0}, Reason {1}", eventArgs.Code, eventArgs.Reason);
DisposeSocket();
if (AbortHandler.TryCompleteAbort() || _disconnectToken.IsCancellationRequested)
{
return;
}
Task.Run(() => Reconnect(_connection, _connectionData));
}
// Close connection
private void Closed(IWebSocket sender, WebSocketClosedEventArgs args)
{
MessageWebSocket webSocket = Interlocked.Exchange(ref messageWebSocket, null);
if (webSocket != null)
{
webSocket.Dispose();
}
}
void IWebSocketListener.OnOpen(IWebSocket socket, Response response)
{
var handler = Open;
if (handler != null)
{
handler(socket, response);
}
}
private async Task RunWebSocket(IDictionary<string, object> websocketContext)
{
object value;
if (websocketContext.TryGetValue(typeof(WebSocketContext).FullName, out value))
{
this.mWebSocket = new NetWebSocket(((WebSocketContext)value).WebSocket);
}
else
{
this.mWebSocket = new OwinWebSocket(websocketContext);
}
this.OnOpen();
var buffer = new byte[this.MaxMessageSize];
Tuple<ArraySegment<byte>, WebSocketMessageType> received = null;
do
{
try
{
received = await this.mWebSocket.ReceiveMessage(buffer, this.mCancellToken.Token);
if (received.Item1.Count > 0)
await this.OnMessageReceived(received.Item1, received.Item2);
}
catch (TaskCanceledException)
{
break;
}
catch (OperationCanceledException oce)
{
if (!this.mCancellToken.IsCancellationRequested)
{
this.OnReceiveError(oce);
}
break;
}
catch (ObjectDisposedException)
{
break;
}
catch (Exception ex)
{
if (IsFatalSocketException(ex))
{
this.OnReceiveError(ex);
}
break;
}
}
while (received.Item2 != WebSocketMessageType.Close);
try
{
await this.mWebSocket.Close(WebSocketCloseStatus.NormalClosure, string.Empty, this.mCancellToken.Token);
}
catch
{ //Ignore
}
if (!this.mCancellToken.IsCancellationRequested)
this.mCancellToken.Cancel();
this.OnClose(this.mWebSocket.CloseStatus, this.mWebSocket.CloseStatusDescription);
}
private async Task AcceptWebSocketRequest(ITransportConnection connection)
{
var handler = new DefaultWebSocketHandler(_maxIncomingMessageSize, Logger);
// Configure event handlers before calling ProcessWebSocketRequestAsync
_socket = handler;
_socket.OnClose = _closed;
_socket.OnMessage = _message;
_socket.OnError = _error;
WebSocket webSocket;
try
{
webSocket = await Context.AcceptWebSocketAsync();
}
catch
{
// Bad Request
_context.Response.StatusCode = 400;
await _context.Response.WriteAsync(Resources.Error_NotWebSocketRequest);
return;
}
// Start the websocket handler so that we can process things over the channel
var webSocketHandlerTask = handler.ProcessWebSocketRequestAsync(webSocket, CancellationToken);
// This needs to come after wiring up the websocket handler
var ignoredTask = ProcessRequestCore(connection)
.ContinueWith(async (_, state) =>
{
await ((DefaultWebSocketHandler)state).CloseAsync();
},
handler);
await webSocketHandlerTask;
}
public WebSocketClient(IWebSocket webSocket)
{
this.webSocket = webSocket;
webSocket.BeginReceiveMessage(HandleBeginReceiveMessageCompleted, null);
}
private void OnCloseReceived(IWebSocket sender, WebSocketClosedEventArgs args)
{
var recvResult = new WebSocketReceiveResult(0, WebSocketMessageType.Close, true, (WebSocketCloseStatus)args.Code,
args.Reason);
_closeWebSocketReceiveResultTcs.TrySetResult(recvResult);
}
public WebSocketRequest(IWebSocket webSocket)
{
Debug.Assert(webSocket != null, "webSocket is null");
_webSocket = webSocket;
}
