/// <summary> /// Connect to the server and start processing messages /// </summary> public void Connect() { _webSocket?.Dispose(); _disconnectCalled = false; // get the connection info from the signalr host var connInf = SignalR.Negotiate(_httpHost, _hubs); // we only work with websockets if (!connInf.TryWebSockets) { throw new WebSocketException(WebSocketError.UnsupportedProtocol, "WebSocket Connections Not Supported By This Host"); } _connectionToken = connInf.ConnectionToken; _connectionId = connInf.ConnectionId; _webSocket = SignalR.Connect(_wsHost, _connectionToken, _hubs); HookupEvents(); _webSocket.Connect(); if (Debug) { WriteLine($"Connect Called, URL: {_rootHost}"); } }
public async Task <bool> Connect() { try { _webSocket.OnStateChanged += _webSocket_OnStateChanged; _webSocket.OnMessage += _webSocket_OnMessage; _webSocket.OnClosed += _webSocket_OnClosed; _webSocket.OnSendFailed += _webSocket_OnSendFailed; _webSocket.OnData += _webSocket_OnData; try { _loxData = await webApi.GetBasicAuthRequest <LoxApp3Data>("/data/LoxAPP3.json"); } catch { return(false); } _keepAliveTimer.Start(); var connect = _webSocket.Connect(); if (connect) { await InitConnection(); } return(connect); } catch (Exception e) { throw; } }
public static void Main(string[] args) { _timer = new Timer(OnTick, null, 2000, 1); RESTART: var socketOptions = new PureWebSocketOptions() { DebugMode = true, SendDelay = 100, IgnoreCertErrors = true, MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20) }; _ws = new PureWebSocket("wss://echo.websocket.org", socketOptions); _ws.OnStateChanged += Ws_OnStateChanged; _ws.OnMessage += Ws_OnMessage; _ws.OnClosed += Ws_OnClosed; _ws.OnSendFailed += Ws_OnSendFailed; _ws.Connect(); Console.ReadLine(); _ws.Dispose(true); goto RESTART; }
/// <summary> /// State used while trying to connect. /// </summary> private void Connecting() { Log.Information("State::Connecting."); Receive <Socket_Connected>(msg => Become(Subscribed)); Receive <Socket_Disconnected>(msg => Become(Disconnected)); Log.Information("Starting connection to {0}.", _url); // start connecting _socket = new PureWebSocket( _url, new PureWebSocketOptions { SendDelay = 100, DebugMode = false }); _socket.OnStateChanged += Socket_OnStateChanged(Self); _socket.OnMessage += Socket_OnMessage(_subscriber); _socket.OnClosed += Socket_OnClosed(Self); try { _socket.Connect(); } catch { // socket close handler will be called } }
public void Connect() { if (IsConnected()) { return; } Disconnect(() => { var opts = new PureWebSocketOptions { MyReconnectStrategy = new ReconnectStrategy(1000, 30000) }; _conn = new PureWebSocket(_endPoint, opts); _conn.OnOpened += OnConnOpen; _conn.OnError += OnConnError; _conn.OnMessage += OnConnMessage; _conn.OnClosed += OnConnClose; try { _conn.Connect(); _reconnectTimer.Stop(); } catch (Exception ex) { _reconnectTimer.Start(); } }); }
internal bool Connect() { _websocket = new PureWebSocket(_url, _purePusherClient.Options); _websocket.OnOpened += _websocket_OnOpened; _websocket.OnError += _websocket_OnError; _websocket.OnClosed += _websocket_OnClosed; _websocket.OnFatality += _websocket_OnFatality; _websocket.OnMessage += _websocket_OnMessage; return(_websocket.Connect()); }
public void Connect(string url) { ws = new PureWebSocket(url, new ReconnectStrategy(10000, 60000)); ws.OnMessage += OnMessage; ws.OnSendFailed += OnSendFailed; ws.OnError += OnError; ws.OnClosed += OnClosed; ws.OnStateChanged += OnStateChanged; ws.OnOpened += Ws_OnOpened; ws.Connect(); }
public bool Connect() { Log("Connect invoked."); try { return(_socket.Connect()); } catch (Exception ex) { Log($"Connect thew an exception, {ex.Message}."); Socket_OnError(this, ex); throw; } }
internal async Task <JsonZKill.Killmail> GetSocketResponce() { try { if (_webSocket == null || _webSocket.State != WebSocketState.Open) { if (_webSocket?.State == WebSocketState.Connecting) { return(null); } var o = new PureWebSocketOptions(); _webSocket?.Dispose(); _webSocket = new PureWebSocket(SettingsManager.Settings.Config.ZKillboardWebSocketUrl, o); _webSocket.OnMessage += _webSocket_OnMessage; _webSocket.OnError += async exception => { await LogHelper.LogEx("_webSocket.OnError", exception, LogCat.ZKill); }; if (!_webSocket.Connect()) { _webSocket?.Dispose(); _webSocket = null; return(null); } else { if (!_webSocket.Send("{\"action\":\"sub\",\"channel\":\"killstream\"}")) { _webSocket?.Dispose(); _webSocket = null; return(null); } await LogHelper.LogInfo("ZKB feed core WebSocket connect successful!", LogCat.ZKill); } } if (!_webMailsQueue.IsEmpty && _webMailsQueue.TryDequeue(out var km)) { return(km); } } catch (Exception ex) { await LogHelper.LogEx("GetSocketResponce", ex, LogCat.ZKill); _webSocket?.Dispose(); _webSocket = null; } return(null); }
/// <summary> /// Connects to a UserData Websocket endpoint. /// </summary> /// <param name="parameters">Paremeters to send to the Websocket.</param> /// <param name="accountHandler">Deletage to callback after receive a account info message.</param> /// <param name="tradeHandler">Deletage to callback after receive a trade message.</param> /// <param name="orderHandler">Deletage to callback after receive a order message.</param> public void ConnectToUserDataWebSocket(string parameters, MessageHandler <AccountUpdatedMessage> accountHandler, MessageHandler <OrderOrTradeUpdatedMessage> tradeHandler, MessageHandler <OrderOrTradeUpdatedMessage> orderHandler) { var finalEndpoint = _webSocketEndpoint + parameters; var ws = new PureWebSocket(finalEndpoint, new PureWebSocketOptions() { DebugMode = false,//true, SendDelay = 10, IgnoreCertErrors = true, MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20) }); ws.OnMessage += (data) => { var eventData = JsonConvert.DeserializeObject <dynamic>(data); switch (eventData.e) { case "outboundAccountInfo": accountHandler(JsonConvert.DeserializeObject <AccountUpdatedMessage>(data)); break; case "executionReport": var isTrade = ((string)eventData.x).ToLower() == "trade"; if (isTrade) { tradeHandler(JsonConvert.DeserializeObject <OrderOrTradeUpdatedMessage>(data)); } else { orderHandler(JsonConvert.DeserializeObject <OrderOrTradeUpdatedMessage>(data)); } break; } }; ws.OnClosed += (reason) => { _openSockets.Remove(ws); }; ws.OnError += (error) => { _openSockets.Remove(ws); }; ws.Connect(); _openSockets.Add(ws); }
public static void Main(string[] args) { _timer = new Timer(OnTick, null, 2000, 1); RESTART: _ws = new PureWebSocket("wss://echo.websocket.org", new ReconnectStrategy(10000, 60000)); _ws.SendDelay = 100; _ws.OnStateChanged += Ws_OnStateChanged; _ws.OnMessage += Ws_OnMessage; _ws.OnClosed += Ws_OnClosed; _ws.OnSendFailed += Ws_OnSendFailed; _ws.Connect(); Console.ReadLine(); _ws.Dispose(true); goto RESTART; }
protected override async Task GetExchangeDataAsync(CancellationToken ct) { var options = new PureWebSocketOptions { DebugMode = false }; using (var ws = new PureWebSocket(TickerUrl, options)) { var closed = false; ws.OnMessage += WsOnMessage; ws.OnClosed += reason => { Logger.Info($"Binance closed: {reason}"); closed = true; }; ws.OnError += exception => { Logger.Error(exception); closed = true; }; if (!ws.Connect( )) { Logger.Error("Couldn't connect to Binance"); } while (ws.State != WebSocketState.Closed) { if (UpTime > LastUpdateDuration && LastUpdateDuration > TimeSpan.FromHours(1) || closed) { ws.Disconnect( ); break; } await Task.Delay(PollingRate, ct).ConfigureAwait(false); } } }
/// <summary> /// Connects to a Websocket endpoint. /// </summary> /// <typeparam name="T">Type used to parsed the response message.</typeparam> /// <param name="parameters">Paremeters to send to the Websocket.</param> /// <param name="messageDelegate">Deletage to callback after receive a message.</param> /// <param name="useCustomParser">Specifies if needs to use a custom parser for the response message.</param> public void ConnectToWebSocket <T>(string parameters, MessageHandler <T> messageHandler, bool useCustomParser = false) { var finalEndpoint = _webSocketEndpoint + parameters; var ws = new PureWebSocket(finalEndpoint, new PureWebSocketOptions() { DebugMode = false,//true, SendDelay = 10, IgnoreCertErrors = true, MyReconnectStrategy = new ReconnectStrategy(2000, 4000, 20) }); ws.OnMessage += (data) => { dynamic eventData; if (useCustomParser) { var customParser = new CustomParser(); eventData = customParser.GetParsedDepthMessage(JsonConvert.DeserializeObject <dynamic>(data)); } else { eventData = JsonConvert.DeserializeObject <T>(data); } messageHandler(eventData); }; ws.OnClosed += (reason) => { _openSockets.Remove(ws); }; ws.OnError += (error) => { _openSockets.Remove(ws); }; ws.Connect(); _openSockets.Add(ws); }
private void ConnectionMonitorCheck(object state) { if (_disposedValue || _disconnectCalled) { return; } if (_lastMessageTime.AddSeconds(30) > DateTime.Now) { return; } if (Debug) { WriteLine("Connection Timeout, Atempting Reconnect"); } _webSocket.Dispose(false); _webSocket = SignalR.Reconnect(_wsHost, _connectionToken, _hubs, _lastMessageId, _groupsToken); HookupEvents(); _webSocket.Connect(); }
protected override void DoOpen() { Logger.Log("DoOpen uri =" + Uri()); var myheaders = new List <Tuple <string, string> >(); myheaders.AddRange(_myExtraHeaders); myheaders.Add(new Tuple <string, string>("Cookie", _cookies)); var options = new PureWebSocketOptions { Headers = myheaders }; Ws = new PureWebSocket(Uri(), options); Ws.OnOpened += Ws_OnOpened; Ws.OnClosed += Ws_OnClosed; Ws.OnData += Ws_OnData; Ws.OnMessage += Ws_OnMessage; Ws.OnError += Ws_OnError; Ws.Connect(); }
private void SocketClosed(WebSocketCloseStatus reason) { _logger.Warning("Socket closed. Reason: {Reason}", reason); _webSocket.Connect(); }
public void Connect() { webSocket.Connect(); Debug.WriteLine($"[WS] Connecting to {WebSocketUrl}..."); }