/// <summary> /// The function to be called for each message received on listening websocket /// </summary> /// <param name="message">The message received</param> /// <param name="ws">The websocket on which the message was received</param> void OnMessage(string message, WebSocketWrapper ws) { Console.WriteLine(message); if (message == null || message == "") { return; } try { Response response = JsonConvert.DeserializeObject <Response>(message); response.Handle(message, this); } catch (WebSocketException e) { Console.WriteLine("Exception in websocket:"); Console.WriteLine(e); } catch (Exception e) { Console.WriteLine(message); Console.WriteLine("{0}: {1}", e.GetType(), e.Message); ws.Close(); } }
private static async Task TestPoloniex() { var uri = new Uri("wss://api2.poloniex.com"); using (var socket = new WebSocketWrapper(uri)) { MessageArrived(socket); await socket.ConnectAsync(); // subscribe to chanell BTC_NXT await socket.SendAsync(new { command = "subscribe", channel = 69 }); await Task.Delay(10000); await socket.SendAsync(new { command = "unsubscribe", channel = 69 }); await Task.Delay(500); } }
public async Task Start() { if (_started) { throw new Exception("already_started"); } await Task.Run(() => WebSocketClientWrapper.ConnectAsync( $"wss://{_options.Url}:{_options.Port}", CancellationToken.None, (context) => { _socketWrapper = context; context.OnOpen += OnOpen; context.OnClose += _options.OnClose; context.OnError += _options.OnError; context.OnReceive += OnReceived; _options.OnConnected?.Invoke(); }, true, false, 3, _options.InternalWebSocketOptions )); }
/// <summary> /// Connects to Cirrus /// </summary> /// <returns>If the connection was successfully opened</returns> public bool Connect() { socket = WebSocketWrapper.Create(Config.ReadSetting("YanziHost")); try { socket.Connect(); } catch (Exception e) { Console.WriteLine("Could not connect to Cirrus"); //Console.WriteLine(e); return(false); } if (socket.State() != WebSocketState.Open) { Console.WriteLine("Could not connect to Cirrus"); return(false); } socket.OnConnect((WebSocketWrapper ws) => Console.WriteLine("Has connected")); socket.OnMessage(OnMessage); socket.OnDisconnect((WebSocketWrapper ws) => Create()); return(true); }
private async void Websocket_OnClosed(object sender, WebSocketWrapper socket) { await ExecuteSafeAsync(async() => { SendChatLog("Websocket: Connection Closed", ChatLogType.Debug); await Disconnect(true); }); }
public ProvisioningSocket(string httpUri, CancellationToken token) { Token = token; WsUri = httpUri.Replace("https://", "wss://") .Replace("http://", "ws://") + "/v1/websocket/provisioning/"; WebSocket = new WebSocketWrapper(WsUri, token); WebSocket.OnMessage(Connection_OnMessage); }
public ServerCommandListener(MazeSocketConnector connector, WebSocketWrapper mazeSocket, MazeServer mazeServer, ILifetimeScope container) { _connector = connector; _mazeSocket = mazeSocket; _mazeServer = mazeServer; _container = container; }
private async Task ParseMessage(SocketEventHandlerArgs msg) { string symbol = msg.chnlName; switch (msg.type) { case StreamMessageType.Data: { var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length); if (String.IsNullOrEmpty(jsonResponse)) { _logger.Log(LogPriority.Warning, $"<--Report : Empty message received - '{jsonResponse}' : ", ExchName); return; } if (symbol.Equals(BinanceClient.connectSymbol + "@ticker")) { return; } JObject jToken = JObject.Parse(jsonResponse); var symbolItem = jToken["s"].ToString(); MarketBook mb = new MarketBook() { AskPrice = jToken["a"].ToObject <double>(), AskSize = jToken["A"].ToObject <double>(), BidPrice = jToken["b"].ToObject <double>(), BidSize = jToken["B"].ToObject <double>(), ServerTime = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddMilliseconds(jToken["E"].ToObject <double>()), LocalTime = DateTime.Now }; _client.OnReport(ExchName, ExchName + symbolItem, mb); } break; case StreamMessageType.Logon: { _client.OnEvent(ExchName, BrokerEvent.ConnectorStarted, string.Empty); using (await _lock.LockAsync()) { if (SubscribeList.Count > 0) { foreach (var i in SubscribeList) { chnl = new WebSocketWrapper(Uri + i.Key, i.Key, _logger, ExchName); await chnl.Start(ParseMessage); } } } } break; default: break; } }
public ServerHub(Uri uri) { HubUri = uri; ConnectLoop = new CancellableRunLoop(); ConnectLoop.LoopIterationEvent += ConnectLoop_LoopIterationEvent; Socket = new WebSocketWrapper(HubUri); Socket.KeepAlive += Socket_KeepAlive; Socket.OnConnected += Socket_OnConnected; Socket.DataReceived += Socket_DataReceived; }
public async Task Start(string endpoint, Instrument pair, SubscriptionModel model) { Id = pair.Id(); _endpoint = endpoint; _pair = pair; _model = model; chnl = new WebSocketWrapper(Uri + _endpoint, _endpoint, _logger, ExchName); await chnl.Start(ParseMessage); }
public async Task InvokeAsync(HttpContext context) { if (!context.WebSockets.IsWebSocketRequest) { await _next(context); return; } if (!context.User.Identity.IsAuthenticated) { context.Response.StatusCode = (int)HttpStatusCode.Unauthorized; return; } var socket = await context.WebSockets.AcceptWebSocketAsync(); var wrapper = new WebSocketWrapper(socket, _options.PackageBufferSize); var server = new MazeServer(wrapper, _options.PackageBufferSize, _options.MaxHeaderSize, ArrayPool <byte> .Shared); if (context.User.IsAdministrator()) { var accountId = context.User.GetAccountId(); var connection = new AdministrationConnection(accountId, wrapper, server); _connectionManager.AdministrationConnections.TryAdd(accountId, connection); try { await connection.BeginListen(); } finally { _connectionManager.AdministrationConnections.TryRemove(accountId, out _); } } else { var clientId = context.User.GetClientId(); var connection = new ClientConnection(clientId, wrapper, server); _connectionManager.ClientConnections.TryAdd(clientId, connection); _serviceProvider.Execute <IClientConnectedAction, IClientConnection>(connection).Forget(); try { await connection.BeginListen(); } finally { _connectionManager.ClientConnections.TryRemove(clientId, out _); } await _serviceProvider.Execute <IClientDisconnectedAction, int>(connection.ClientId); } }
private void _CreateWebsocket() { var headers = new Dictionary <string, string>(StringComparer.CurrentCultureIgnoreCase); headers.Add("origin", "https://plug.dj"); Websocket = new WebSocketWrapper(null, headers); Websocket.OnMessageReceived += Websocket_OnMessage; Websocket.OnConnected += Websocket_OnOpened; Websocket.OnError += Websocket_OnError; Websocket.OnDisconnected += Websocket_OnClosed; }
public MainPage() { InitializeComponent(); UserInfo.Messages = new System.Collections.Generic.List <Message>(); messages = new ObservableCollection <Message>(); #region WebSocket Handling var uri = new Uri("ws://" + SERVER_ADDRESS + "?impuAddress=" + Uri.EscapeDataString(UserInfo.Number)); socket = WebSocketWrapper.Create(uri); socket.Connect(); socket.OnMessage += (w, message) => { Console.WriteLine("Received Message: " + message); var package = JsonConvert.DeserializeObject <WebSocketPackage>(message); if (package.callEvent == "CalledNumber") { inACall = true; } if (!String.IsNullOrEmpty(package.mediaInteractionResult)) { var answer = "[RESPONSE]: " + package.mediaInteractionResult; UserInfo.Messages.Add(new Message { Date = DateTime.Now, Text = answer, Number = UserInfo.LatestPartnerNumber }); //messages.Add(new Message() //{ // Number = GetSignitureInGoodFormat(DateTime.Now, ChannelPicker.SelectedItem.ToString(), UserInfo.LatestPartnerNumber), // Text = answer, //}); RefreshListView(); } }; socket.OnDisconnected += (w) => { inACall = false; }; #endregion if (ChannelPicker.SelectedItem == null) { ChannelPicker.SelectedItem = "0"; } //RefreshListView(); RefreshBannerLine(); lstView.ItemsSource = messages; }
protected override IBrokerage CreateBrokerage(IOrderProvider orderProvider, ISecurityProvider securityProvider) { var restClient = new RestClient("https://api.gdax.com"); var webSocketClient = new WebSocketWrapper(); var algorithm = new Mock <IAlgorithm>(); algorithm.Setup(a => a.BrokerageModel).Returns(new BitfinexBrokerageModel(AccountType.Cash)); return(new BitfinexBrokerage(Config.Get("gdax-url", "wss://ws-feed.gdax.com"), webSocketClient, restClient, Config.Get("bitfinex-api-key"), Config.Get("bitfinex-api-secret"), algorithm.Object)); }
public void GetsHistory(Symbol symbol, Resolution resolution, TickType tickType, TimeSpan period, bool shouldBeEmpty) { var restClient = new RestClient("https://api.pro.coinbase.com"); var webSocketClient = new WebSocketWrapper(); var brokerage = new GDAXBrokerage( Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"), webSocketClient, restClient, Config.Get("gdax-api-key"), Config.Get("gdax-api-secret"), Config.Get("gdax-passphrase"), null, null); var historyProvider = new BrokerageHistoryProvider(); historyProvider.SetBrokerage(brokerage); historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null, null, null, null, null)); var now = DateTime.UtcNow; var requests = new[] { new HistoryRequest(now.Add(-period), now, typeof(TradeBar), symbol, resolution, SecurityExchangeHours.AlwaysOpen(TimeZones.Utc), DateTimeZone.Utc, resolution, false, false, DataNormalizationMode.Adjusted, tickType) }; var history = historyProvider.GetHistory(requests, TimeZones.Utc).ToList(); foreach (var slice in history) { var bar = slice.Bars[symbol]; Log.Trace($"{bar.Time}: {bar.Symbol} - O={bar.Open}, H={bar.High}, L={bar.Low}, C={bar.Close}, V={bar.Volume}"); } if (shouldBeEmpty) { Assert.IsTrue(history.Count == 0); } else { Assert.IsTrue(history.Count > 0); } Log.Trace("Data points retrieved: " + historyProvider.DataPointCount); }
private void OnConnect(WebSocketWrapper wrapper) { _symbolLookup = new Dictionary <string, string>(); foreach (var coin in _exchange.Coins) { foreach (var childCoin in coin.Coins) { var symbol = coin.Symbol + childCoin.Symbol; _symbolLookup.Add(symbol, $"{coin.Symbol},{childCoin.Symbol}"); var json = "{\"method\":\"subscribeTicker\",\"params\":{\"symbol\":\"" + symbol + "\"}, \"id\": 123}"; wrapper.SendMessage(json); } } }
public void Monitor() { try { var socket = WebSocketWrapper.Create("wss://api.hitbtc.com/api/2/ws"); socket.OnConnect(OnConnect); socket.OnMessage(OnMessage); socket.OnDisconnect(OnDisconnect); socket.Connect(); } catch (Exception ex) { Colorful.Console.WriteLine($"HitBtc Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red); } }
public void Monitor() { try { var socket = WebSocketWrapper.Create("wss://ws-feed.gdax.com"); socket.OnConnect(OnConnect); socket.OnMessage(OnMessage); socket.OnDisconnect(OnDisconnect); socket.Connect(); } catch (Exception ex) { Colorful.Console.WriteLine($"Coinbase Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red); } }
// Start is called before the first frame update void Start() { //unityWebRequest = new UnityWebRequest(); //DoFetch(); wsw = WebSocketWrapper.Create(socketURL); onMessageAction = OnMessageCallback; onConnectAction = OnConnectCallback; wsw.OnConnect(onConnectAction); wsw.OnMessage(onMessageAction); wsw.Connect(); }
protected override IBrokerage CreateBrokerage(IOrderProvider orderProvider, ISecurityProvider securityProvider) { var restClient = new RestClient("https://api.pro.coinbase.com"); var webSocketClient = new WebSocketWrapper(); var algorithm = new Mock <IAlgorithm>(); algorithm.Setup(a => a.BrokerageModel).Returns(new GDAXBrokerageModel(AccountType.Cash)); var priceProvider = new ApiPriceProvider(Config.GetInt("job-user-id"), Config.Get("api-access-token")); return(new GDAXBrokerage(Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"), webSocketClient, restClient, Config.Get("gdax-api-key"), Config.Get("gdax-api-secret"), Config.Get("gdax-passphrase"), algorithm.Object, priceProvider)); }
public void Monitor() { try { var channels = BuildChannels(); var socket = WebSocketWrapper.Create($"wss://stream.binance.com:9443/ws{channels}"); socket.OnMessage(OnMessage); socket.OnDisconnect(OnDisconnect); socket.Connect(); } catch (Exception ex) { Colorful.Console.WriteLine($"Binance Monitor(): {ex.Message}", Color.Red); } }
private static GDAXBrokerage GetBrokerage() { var wssUrl = Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"); var webSocketClient = new WebSocketWrapper(); var restClient = new RestClient("https://api.pro.coinbase.com"); var apiKey = Config.Get("gdax-api-key"); var apiSecret = Config.Get("gdax-api-secret"); var passPhrase = Config.Get("gdax-passphrase"); var algorithm = new QCAlgorithm(); var userId = Config.GetInt("job-user-id"); var userToken = Config.Get("api-access-token"); var priceProvider = new ApiPriceProvider(userId, userToken); return(new GDAXBrokerage(wssUrl, webSocketClient, restClient, apiKey, apiSecret, passPhrase, algorithm, priceProvider)); }
private static GDAXBrokerage GetBrokerage() { var wssUrl = Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"); var webSocketClient = new WebSocketWrapper(); var restClient = new RestClient("https://api.pro.coinbase.com"); var apiKey = Config.Get("gdax-api-key"); var apiSecret = Config.Get("gdax-api-secret"); var passPhrase = Config.Get("gdax-passphrase"); var algorithm = new QCAlgorithm(); var brokerage = new GDAXBrokerage(wssUrl, webSocketClient, restClient, apiKey, apiSecret, passPhrase, algorithm); brokerage.Connect(); return(brokerage); }
private void OnMessage(string message, WebSocketWrapper wrapper) { if (string.IsNullOrEmpty(message)) { return; } var items = JsonConvert.DeserializeObject <TickerChannelDto>(message); if (items.Type == "ticker") { var pricingItem = _builderFactory.Create <TickerChannelDto, PricingItem>(items).Build(); var fromSymbol = items.Product_Id.Split("-")[0]; var toSymbol = items.Product_Id.Split("-")[1]; _serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Coinbase, fromSymbol, toSymbol, pricingItem); } }
private void OnMessage(string message, WebSocketWrapper wrapper) { var item = JsonConvert.DeserializeObject <ResponseDto <TickerDto> >(message); if (item.Method == "ticker" && !string.IsNullOrEmpty(item.Params.Ask) && !string.IsNullOrEmpty(item.Params.Bid)) { var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(item.Params).Build(); if (_symbolLookup.ContainsKey(item.Params.Symbol)) { var symbolPair = _symbolLookup[item.Params.Symbol].Split(","); var fromSymbol = symbolPair[0]; var toSymbol = symbolPair[1]; _serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.HitBtc, fromSymbol, toSymbol, pricingItem); } } }
/// <summary> /// Play sound when recieving message with active alarm /// </summary> /// <param name="message"></param> /// <param name="socketWrapper"></param> private async void OnMessageAsync(string message, WebSocketWrapper socketWrapper) { var webSocketDefinition = new { globalAlarmId = "", active = true }; //active = true is active alarm var webSocketMessage = message.GetJsonObject(webSocketDefinition); if (!_alreadyPlayed.Contains(webSocketMessage.globalAlarmId)) { _alreadyPlayed.Add(webSocketMessage.globalAlarmId); var alarmInfo = await _httpRequest.GetAlarmInfo(webSocketMessage.globalAlarmId, _accesstoken); if (webSocketMessage.active && alarmInfo > 0) { _soundService.PlaySound(); } } }
private void Socket_DataReceived(WebSocketWrapper wrapper, ArraySegment <byte> data) { try { IMessage message = JsonSerializer.Deserialize <IMessage>(data, new JsonSerializerOptions { PropertyNameCaseInsensitive = true, }); if (message == null) { return; } switch (message.Type) { case ChatMessage.TypeString: if (IMessage.TryParseMessage <ChatMessage>(data, out ChatMessage chatMessage)) { ChatMessageReceived?.Invoke(chatMessage); } else { Console.WriteLine(String.Format("Unable to parse ChatMessage out of ChatMessage header.")); } break; case ServerCommand.TypeString: if (IMessage.TryParseMessage <ServerCommand>(data, out ServerCommand serverCommand)) { ServerCommandReceived?.Invoke(serverCommand); } else { Console.WriteLine(String.Format("Unable to parse ServerCommand out of ServerCommand header.")); } break; default: Console.WriteLine(String.Format("Unhandled Hub Message of type = {0}", message.Type)); break; } } catch (Exception e) { Console.WriteLine(String.Format("Error deserializing Json message = {0}", e.ToString())); } }
private static void MessageArrived(WebSocketWrapper socket) { socket.MessageArrived += (message) => { Console.WriteLine(message); }; socket.ConnectionClosed += () => { Console.WriteLine("Connection Closed"); }; socket.ConnectionError += (exception) => { Console.WriteLine("Connection Error"); }; }
public static void Main(string[] args) { var configuration = new ConfigurationBuilder() .AddCommandLine(args) .Build(); string peers = configuration["peers"]; Console.WriteLine(peers); if (!string.IsNullOrEmpty(peers)) { foreach (var peer in peers.Split(',')) { WebSocketWrapper peerConnection = WebSocketWrapper.Create(peer); peerConnection.OnConnect(wsw => { Console.WriteLine($"connected to {peer}"); }); peerConnection.OnMessage((message, wsw) => { Console.WriteLine(Convert.ToBase64String(message)); Blockchain bc = DeserializeBlockchain(message); Console.WriteLine($"LENGTH: {bc.Length} blocks - Last Block Timestamp {bc.LastBlock.Timestamp}"); }); connectedClients.Add(peerConnection); peerConnection.Connect(); peerConnection.OnDisconnect(wsw => { Console.WriteLine($"Disconnecting..."); connectedClients.Remove(wsw); }); } } var host = new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .UseStartup <Startup>() .UseApplicationInsights() .UseConfiguration(configuration) .Build(); host.Run(); }
private void OnMessage(string message, WebSocketWrapper wrapper) { if (!string.IsNullOrEmpty(message) && message.Contains("\"e\":\"24hrTicker\"")) { try { var items = JsonConvert.DeserializeObject <TickerDto>(message); var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(items).Build(); var fromSymbol = _channels[items.Symbol.ToUpper()].Split(",")[0]; var toSymbol = _channels[items.Symbol.ToUpper()].Split(",")[1]; _serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(_apiService.Name, fromSymbol, toSymbol, pricingItem); } catch (Exception ex) { Colorful.Console.WriteLine($"Binance OnMessage(): {ex.Message}", Color.Red); } } }