protected override void OnStop() { ClosePort(); this.timer_inv.Enabled = false; websocket.Close(); HelperLog.Info("RFIDService Stop"); //websocket.Close(); }
public void Close() { if (socket.State == WebSocketState.Open) { socket.Close(); } }
public static WebSocketDisposable ReserveConnection(string uri) { Tuple<WebSocket, RefCountDisposable> connection; lock(openConnectionsLock) { if(!openConnections.TryGetValue(uri, out connection)) { Debug.WriteLine("Creating new websocket"); WebSocket ws = new WebSocket(uri); // Set callbacks? ws.Open(); var dispose = Disposable.Create(() => { Debug.WriteLine("Disposing of websocket"); ws.Close(); openConnections.Remove(uri); }); RefCountDisposable refCount = new RefCountDisposable(dispose); connection = Tuple.Create(ws, refCount); openConnections.Add(uri, connection); return new WebSocketDisposable(connection.Item1, connection.Item2.GetDisposable()); } } Debug.WriteLine("Returning old websocket"); return new WebSocketDisposable(connection.Item1, connection.Item2.GetDisposable()); }
private Task DisconnectInternalAsync(int closeCode = 1000, bool isDisposing = false) { _disconnectCancelTokenSource.Cancel(); if (_client == null) { return(Task.Delay(0)); } if (_client.State == WebSocketState.Open) { try { _client.Close(closeCode, ""); } catch { } } _client.MessageReceived -= OnTextMessage; _client.DataReceived -= OnBinaryMessage; _client.Opened -= OnConnected; _client.Closed -= OnClosed; try { _client.Dispose(); } catch { } _client = null; _waitUntilConnect.Reset(); return(Task.Delay(0)); }
/// <summary> /// The pump for received messages. /// </summary> /// <param name="socket">The socket.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The observable stream of messages.</returns> private static IObservable <string> SocketReceivePump(WebSocket4Net.WebSocket socket, CancellationToken cancellationToken) { var dispose = new Action[] { null }; var incoming = new BufferBlock <string>(); EventHandler <MessageReceivedEventArgs> received = (sender, args) => incoming.Post(args.Message); socket.MessageReceived += received; EventHandler <ErrorEventArgs> errored = (sender, args) => { ((ITargetBlock <string>)incoming).Fault(args.Exception); dispose[0](); }; socket.Error += errored; EventHandler closed = (sender, args) => dispose[0](); socket.Closed += closed; dispose[0] = () => { incoming.Complete(); socket.MessageReceived -= received; socket.Error -= errored; socket.Closed -= closed; socket.Close(); }; cancellationToken.Register(dispose[0]); return(incoming.AsObservable().Publish().RefCount()); }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { if (_socket != null) { _socket.Close(); _socket = null; } }
public override Task InternalDisconnectAsync(SocketCloseEventArgs e) { if (_socket.State != ws4net.WebSocketState.Closed) { _socket.Close(); } return(Task.Delay(0)); }
private void CloseAutoServer() { m_WebSocketClient.Close(); if (m_TimerThread != null) { m_TimerThread.Abort(); m_TimerThread = null; } }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool dispose) { if (dispose) { if (_socket != null) { _socket.Close(); _socket = null; } } }
private string SendCommand(string sessionWSEndpoint, string cmd) { WebSocket4Net.WebSocket j = new WebSocket4Net.WebSocket(sessionWSEndpoint); ManualResetEvent waitEvent = new ManualResetEvent(false); ManualResetEvent closedEvent = new ManualResetEvent(false); string message = ""; byte[] data; Exception exc = null; j.Opened += delegate(System.Object o, EventArgs e) { j.Send(cmd); }; j.MessageReceived += delegate(System.Object o, MessageReceivedEventArgs e) { message = e.Message; waitEvent.Set(); }; j.Error += delegate(System.Object o, SuperSocket.ClientEngine.ErrorEventArgs e) { exc = e.Exception; waitEvent.Set(); }; j.Closed += delegate(System.Object o, EventArgs e) { closedEvent.Set(); }; j.DataReceived += delegate(System.Object o, DataReceivedEventArgs e) { data = e.Data; waitEvent.Set(); }; j.Open(); waitEvent.WaitOne(); if (j.State == WebSocket4Net.WebSocketState.Open) { j.Close(); closedEvent.WaitOne(); } if (exc != null) { throw exc; } return(message); }
private void connectSocket() { socket = new WebSocket(socketAdress, "", WebSocketVersion.Rfc6455); if (socket.State == WebSocketState.Open) socket.Close(); socket.EnableAutoSendPing = true; socket.Closed += new EventHandler(socket_Closed); socket.Error += new EventHandler<ErrorEventArgs>(socket_Error); socket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(socket_MessageReceived); socket.Opened += socket_Opened; socket.Open(); Debug.WriteLine("Cybergame socket connected."); }
public Task DisconnectAsync() { if (_webSocket != null) { _webSocket.DataReceived -= OnDataReceived; _webSocket.Close(); SpinWait.SpinUntil(() => _webSocket.State == WebSocketState.Closed, _clientOptions.CommunicationTimeout); } _webSocket = null; return(Task.FromResult(0)); }
protected override void DoClose() { if (ws != null) { try { ws.Close(); } catch (Exception e) { var log = LogManager.GetLogger(Global.CallerName()); log.Info("DoClose ws.Close() Exception= " + e.Message); } } }
private void websocket_Opened(object sender, EventArgs e) { if (this.data != null) { websocket.Send(this.data); } if (this.datas != null && this.datas.Count > 0) { for (int i = 0; i < this.datas.Count; i++) { websocket.Send(this.datas[i]); } } websocket.Close(); }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { if (_socket != null) { var state = State; if (state == WebSocketState.Open || state == WebSocketState.Connecting) { _logger.LogInformation("Sending web socket close message"); _socket.Close(); } _socket = null; } }
protected virtual void Dispose(bool disposing) { if (disposing && _socket != null) { var state = State; if (state == WebSocketState.Open || state == WebSocketState.Connecting) { var logger = LogManager.GetCurrentClassLogger(); logger.Info("Sending web socket close message"); _socket.Close(); } _socket = null; } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { if (_socket != null) { var state = State; if (state == MediaBrowser.Model.Net.WebSocketState.Open || state == MediaBrowser.Model.Net.WebSocketState.Connecting) { _logger.Info("Sending web socket close message"); _socket.Close(); } _socket = null; } }
public void Dispose() { Lock(() => { this.retry = null; if (socket != null) { socket.Close(); socket = null; } if (timer != null) { timer.Dispose(); timer = null; } }, false); }
static void Main(string[] args) { _webSocket = new WebSocket("ws://localhost:44961/wsapp?token=ABCD"); _webSocket.Opened += WebSocketOnOpened; _webSocket.Closed += (sender, eventArgs) => Console.WriteLine("Closed"); _webSocket.Error += (sender, eventArgs) => Console.WriteLine("Error" + eventArgs.Exception); _webSocket.MessageReceived += (sender, eventArgs) => Console.WriteLine(eventArgs.Message); _webSocket.DataReceived += (sender, eventArgs) => Console.WriteLine("Data received"); _webSocket.Open(); while (Console.ReadKey().KeyChar != 'q') { Console.WriteLine(); } _webSocket.Close(); }
public void TestConnection() { var webSocketClient = new WebSocket("ws://echo.websocket.org"); //webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(5000)) { Assert.Fail("Failed to Opened session ontime"); } Assert.AreEqual(WebSocketState.Open, webSocketClient.State); for (var i = 0; i < 10; i++) { var message = Guid.NewGuid().ToString(); webSocketClient.Send(message); if (!m_MessageReceiveEvent.WaitOne(5000)) { Assert.Fail("Failed to get echo messsage on time"); break; } Assert.AreEqual(m_CurrentMessage, message); } webSocketClient.Close(); if (!m_CloseEvent.WaitOne(5000)) { Assert.Fail("Failed to close session ontime"); } Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); }
public List<SniperInfo> FindAll() { List<SniperInfo> newSniperInfos = new List<SniperInfo>(); try { using (var client = new WebSocket(URL, "basic", WebSocketVersion.Rfc6455)) { client.MessageReceived += (s, e) => { var message = e.Message; var match = Regex.Match(message, @"^(1?\d+)\[""[a|b]"",""(2?.*)""\]$"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfos = Parse(match.Groups[2].Value); if (sniperInfos != null && sniperInfos.Any()) { newSniperInfos.AddRange(sniperInfos); } } } }; client.Open(); Thread.Sleep(Timeout); client.Close(); } } catch (Exception e) { Log.Warn("Received error from Pokezz. More info the logs"); Log.Debug("Received error from Pokezz: ", e); } return newSniperInfos; }
public void SendMessageTest() { WebSocket webSocketClient = new WebSocket(string.Format("ws://127.0.0.1:{0}/websocket", m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(1000)) Assert.Fail("Failed to Opened session ontime"); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 10; i++) { sb.Append(Guid.NewGuid().ToString()); } string messageSource = sb.ToString(); Random rd = new Random(); for (int i = 0; i < 100; i++) { int startPos = rd.Next(0, messageSource.Length - 2); int endPos = rd.Next(startPos + 1, messageSource.Length - 1); string message = messageSource.Substring(startPos, endPos - startPos); webSocketClient.Send("ECHO " + message); Console.WriteLine("Client:" + message); if (!m_MessageReceiveEvent.WaitOne(1000)) Assert.Fail("Cannot get response in time!"); Assert.AreEqual(message, m_CurrentMessage); } webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); }
public void ConnectionTest() { WebSocket webSocketClient = new WebSocket(string.Format("ws://127.0.0.1:{0}/websocket", m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(1000)) Assert.Fail("Failed to Opened session ontime"); Assert.AreEqual(WebSocketState.Open, webSocketClient.State); webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); }
public void IncorrectDNSTest() { WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", "ws://localhostx", m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error); webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(2000)) Assert.Fail("Failed to Opened session ontime"); Assert.AreEqual(WebSocketState.Open, webSocketClient.State); webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); }
public void TestWebSocketOrg() { WebSocket webSocketClient = new WebSocket("ws://echo.websocket.org/"); webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error); webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(5000)) Assert.Fail("Failed to Opened session ontime"); Assert.AreEqual(WebSocketState.Open, webSocketClient.State); for (var i = 0; i < 10; i++) { var message = Guid.NewGuid().ToString(); webSocketClient.Send(message); if (!m_MessageReceiveEvent.WaitOne(5000)) { Assert.Fail("Failed to get echo messsage on time"); break; } Console.WriteLine("Received echo message: {0}", m_CurrentMessage); Assert.AreEqual(m_CurrentMessage, message); } webSocketClient.Close(); if (!m_CloseEvent.WaitOne(5000)) Assert.Fail("Failed to close session ontime"); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); }
public void SendPingReactTest() { WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(2000)) Assert.Fail("Failed to Opened session ontime"); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 10; i++) { sb.Append(Guid.NewGuid().ToString()); } string messageSource = sb.ToString(); Random rd = new Random(); for (int i = 0; i < 10; i++) { int startPos = rd.Next(0, messageSource.Length - 2); int endPos = rd.Next(startPos + 1, messageSource.Length - 1); string message = messageSource.Substring(startPos, endPos - startPos); Console.WriteLine("PING:" + message); webSocketClient.Send("PING " + message); } Thread.Sleep(5000); webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); }
public void UnreachableReconnectTestB() { StopServer(); WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error); webSocketClient.Error += (s, e) => { m_OpenedEvent.Set(); }; webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); m_OpenedEvent.WaitOne(); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); StartServer(); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(5000)) Assert.Fail("Failed to Opened session ontime"); Assert.AreEqual(WebSocketState.Open, webSocketClient.State); m_CloseEvent.Reset(); webSocketClient.Close(); if (!m_CloseEvent.WaitOne(2000)) Assert.Fail("Failed to close session ontime"); Console.WriteLine("State {0}: {1}", webSocketClient.GetHashCode(), webSocketClient.State); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); }
public List<SniperInfo> FindAll() { List<SniperInfo> newSniperInfos = new List<SniperInfo>(); try { using (var client = new WebSocket(URL, "basic", null, new List<KeyValuePair<string, string>>() {new KeyValuePair<string, string>("Referer","http://www.rarespawns.be/"), new KeyValuePair<string, string>("Host", "188.165.224.208:49001") }, "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36", "http://www.rarespawns.be", WebSocketVersion.Rfc6455, null)) { client.MessageReceived += (s, e) => { try { var message = e.Message; if (message == "40") { client.Send("40/pokes"); } var match = Regex.Match(message, @"(1?\d+)+.*\[""helo"",(2?.*)\]"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfos = GetJsonList(match.Groups[2].Value); if (sniperInfos != null && sniperInfos.Any()) { newSniperInfos.AddRange(sniperInfos); } } } else { match = Regex.Match(message, @"(1?\d+)+.*\[""poke"",(2?.*)\]"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfo = GetJson(match.Groups[2].Value); if (sniperInfo != null) { newSniperInfos.Add(sniperInfo); } } } } } catch (Exception ex) { Log.Debug("Error receiving message from RareSpawns", ex); } }; client.Open(); Thread.Sleep(Timeout); client.Close(); } } catch (Exception e) { Log.Warn("Received error from Pokezz. More info the logs"); Log.Debug("Received error from Pokezz: ", e); } return newSniperInfos; }
private void SockUpdate() { ws = new WebSocket(URL); /// 文字列受信 ws.MessageReceived += (s, e) => { // Console.WriteLine("{0}:String Received:{1}", DateTime.Now.ToString(), e.Message); recvText = (e.Message); }; /// バイナリ受信 ws.DataReceived += (s, e) => { IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(e.Data, 0); recvData = (RecvData)Marshal.PtrToStructure(ptr, typeof(RecvData)); string test = recvData.ToString(); LeadIsShow = false; }; /// サーバ接続完了 ws.Opened += (s, e) => { recvData.events = LedEvent.Conect; }; // 接続切れた ws.Closed += (s, e) => { recvData.events = LedEvent.NoneConect; }; /// サーバ接続開始 ws.Open(); /// 送受信ループ while (!IsExit) { // 空いた if (ws.State == WebSocketState.Open) { } // コネクトが出来なけれなもう一度試す if (ws.State == WebSocketState.Closed) { // 1秒スリーブ Thread.Sleep(1000); ws.Open(); } } /// ソケットを閉じる ws.Close(); }
public async Task StreamAsync(Uri uri, CancellationToken token) { Throw.IfNull(uri, nameof(uri)); if (!token.CanBeCanceled) { throw new ArgumentException("Token must be capable of being in the canceled state.", nameof(token)); } token.ThrowIfCancellationRequested(); IsStreaming = true; var webSocket = new WebSocket4Net.WebSocket(uri.ToString(), "basic", WebSocketVersion.Rfc6455); webSocket.Security.AllowUnstrustedCertificate = true; webSocket.Security.AllowNameMismatchCertificate = true; webSocket.EnableAutoSendPing = true; webSocket.DataReceived += WebSocket_DataReceived; //var webSocket = new ClientWebSocket(); //webSocket.Options.KeepAliveInterval = TimeSpan.FromSeconds(30); try { try { webSocket.Open(); if (webSocket.State == WebSocketState.Open) { RaiseOpenEvent(); } } catch (OperationCanceledException) { } catch (Exception e) { if (!token.IsCancellationRequested) { _logger?.LogError(e, $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket connect exception."); throw; } } while (!token.IsCancellationRequested) { // do nothing } /* * * var bytes = new byte[ReceiveBufferSize]; * var buffer = new ArraySegment<byte>(bytes); * * while (!token.IsCancellationRequested) * { * var stringBuilder = new StringBuilder(); * stringBuilder.Clear(); * * try * { * WebSocketReceiveResult result; * do * { * if (webSocket.State != WebSocketState.Open) * { * throw new Exception($"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket is not open (state: {webSocket.State})."); * } * * result = await webSocket * .ReceiveAsync(buffer, token) * .ConfigureAwait(false); * * switch (result.MessageType) * { * case WebSocketMessageType.Close: * throw new Exception(result.CloseStatus.HasValue * ? $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket closed ({result.CloseStatus.Value}): \"{result.CloseStatusDescription ?? "[no reason provided]"}\"" * : $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket closed: \"{result.CloseStatusDescription ?? "[no reason provided]"}\""); * * case WebSocketMessageType.Text when result.Count > 0: * stringBuilder.Append(Encoding.UTF8.GetString(bytes, 0, result.Count)); * break; * * case WebSocketMessageType.Binary: * _logger?.LogWarning($"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: Received unsupported binary message type."); * break; * * default: * throw new ArgumentOutOfRangeException(nameof(result.MessageType), $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: Unknown result message type ({result.MessageType})."); * } * } * while (!result.EndOfMessage); * } * catch (OperationCanceledException) { } * catch (Exception e) * { * if (!token.IsCancellationRequested) * { * _logger?.LogError(e, $"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: WebSocket receive exception."); * throw; * } * } * * if (token.IsCancellationRequested) * continue; * * var json = stringBuilder.ToString(); * if (!string.IsNullOrWhiteSpace(json)) * { * RaiseMessageEvent(new WebSocketClientEventArgs(json)); * } * else * { * _logger?.LogWarning($"{nameof(WebSocketClient)}.{nameof(StreamAsync)}: Received empty JSON message."); * } * } */ } finally { IsStreaming = false; // NOTE: WebSocketState.CloseSent should not be encountered since CloseOutputAsync is not used. if (webSocket.State == WebSocketState.Open || webSocket.State == WebSocketState.Closing) { webSocket.Close(); //await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false); } if (webSocket != null) { webSocket.Dispose(); } RaiseCloseEvent(); } }
public bool Connect(string holoChainServerURI) { /* * var services = new ServiceCollection(); * services.AddNodeServices(options => { * // Set any properties that you want on 'options' here * }); */ //CallZomeFunction(holoChainServerURI); //var func = Edge.Func(@"return require('./../myfunc.js')"); //var func = Edge.Func(File.ReadAllText("myfunc.js")); /* * JsonRpcHttpClient client = new JsonRpcHttpClient(new Uri(holoChainServerURI)); * * * client.Invoke<string>("info/instances").ContinueWith((antecedent) => * { * object obj = antecedent.Result; * * if (antecedent.Status == TaskStatus.RanToCompletion) * { * Console.WriteLine("completed"); * } * }); */ //var socket = await this.HttpContext.WebSockets.AcceptWebSocketAsync(); //var jsonRpc = new JsonRpc(new WebSocketMessageHandler(socket), new JsonRpcServer()); //jsonRpc.StartListening(); //await jsonRpc.Completion; // return true; /* * client.Invoke<string>("info/instances", new ).ContinueWith((antecedent) => * { * object obj = antecedent.Result; * * if (antecedent.Status == TaskStatus.RanToCompletion) * { * Console.WriteLine("completed"); * } * });*/ /* * var websocket = new JsonWebSocket(holoChainServerURI); * * websocket.Opened += (sender, e) => * { * websocket.Send("info/instances", * JsonConvert.SerializeObject( * new * { * method = "info/instances", * @params = new { }, * id = 123, * } * ) * ); * * websocket.Send("test-instance/our_world/create_my_entry", * JsonConvert.SerializeObject( * new * { * method = "test-instance/our_world/create_my_entry", * @params = new { entry = new MyEntry { content = "blah" } }, * id = 124, * } * ) * ); * * * * }; * * * Action<string> s = Console.WriteLine; * * websocket.On("info/instances", s); * */ // note: reconnection handling needed. //var websocket = new WebSocket(holoChainServerURI, sslProtocols: SslProtocols.Tls12); //var websocket = new WebSocket(holoChainServerURI, sslProtocols: SslProtocols.Default); var websocket = new WebSocket4Net.WebSocket(holoChainServerURI); websocket.Opened += (sender, e) => { websocket.Send( JsonConvert.SerializeObject( new { method = "info/instances", //@params = new { channel = channelName }, id = 123, } ) ); websocket.Send( JsonConvert.SerializeObject( new { method = "test-instance/our_world_core/create_my_entry", @params = new { entry = new MyEntry { content = "blah" } }, id = 124, } ) ); }; websocket.MessageReceived += (sender, e) => { Console.WriteLine("Message Received: " + e.Message); dynamic data = JObject.Parse(e.Message); if (data.id == 123) { Console.WriteLine("Instance Name Received"); } if (data.@params != null) { Console.WriteLine([email protected] + " " + [email protected]); } //JObject data = JObject.Parse(e.Message); //if (data["id"].v == 123) //{ // Console.WriteLine("Instance Name Received"); //} //if (data.@params != null) //{ // Console.WriteLine([email protected] + " " + [email protected]); //} }; websocket.Open(); websocket.Close(); return(true); //this.Connection = WebSocket.CreateClientBuffer(1024,1024) }
public void Dispose() { webSocket.Close(); }
public bool Close() { m_WebSocketClient.Close(); m_WebSocketClient = null; return(true); }
private void TestClose() { webSocket.Close(); }
static void Main(string[] args) { const string httpScheme = "https://"; const string wsScheme = "wss://"; const string url = "websocket.btcchina.com/socket.io/"; #region handshake string polling = string.Empty; try { WebClient wc = new WebClient(); polling = wc.DownloadString(httpScheme + url + "?transport=polling"); if (string.IsNullOrEmpty(polling)) { Console.WriteLine("failed to download config"); } } catch (Exception ex) { Console.WriteLine(ex.Message); } string config = polling.Substring(polling.IndexOf('{'), polling.IndexOf('}') - polling.IndexOf('{') + 1); wsConfigHelper wsc = JsonConvert.DeserializeObject<wsConfigHelper>(config); #endregion handshake //set timers pingTimeoutTimer = new Timer(_ => { if (pong) { pong = false; //waiting for another ping } else { Console.WriteLine("Ping Timeout!"); } }, null, Timeout.Infinite, Timeout.Infinite); pingIntervalTimer = new Timer(_ => { btc.Send(string.Format("{0}", (int)engineioMessageType.PING)); pingTimeoutTimer.Change(wsc.pingTimeout, Timeout.Infinite); pong = false; }, null, wsc.pingInterval, wsc.pingInterval); //setup websocket connections and events btc = new WebSocket(wsScheme + url + "?transport=websocket&sid=" + wsc.sid); btc.Opened += btc_Opened; btc.Error += btc_Error; btc.MessageReceived += btc_MessageReceived; btc.DataReceived += btc_DataReceived; btc.Closed += btc_Closed; btc.Open(); Console.ReadKey(); //close the connection. btc.Send(string.Format("{0}{1}", (int)engineioMessageType.MESSAGE, (int)socketioMessageType.DISCONNECT)); Console.ReadKey(); pingIntervalTimer.Dispose(); pingTimeoutTimer.Dispose(); btc.Close(); }
public override bool Register(string Username, string Password) { try { HttpWebRequest betrequest = (HttpWebRequest)HttpWebRequest.Create("https://www.bitdice.me/"); if (Prox != null) betrequest.Proxy = Prox; betrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8"; betrequest.CookieContainer = new CookieContainer(); HttpWebResponse EmitResponse = (HttpWebResponse)betrequest.GetResponse(); string sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd(); getcsrf(sEmitResponse); getstream(sEmitResponse); cookie = EmitResponse.Cookies["_csn_session"].Value; if (Client != null) Client.Close(); List<KeyValuePair<string, string>> headers = new List<KeyValuePair<string, string>>(); headers.Add(new KeyValuePair<string, string>("Cookie", "_csn_session=" + cookie)); Client = new WebSocket("wss://www.bitdice.me/stream/" + stream, "", null, headers, "dicebot", "http://bitdice.me", WebSocketVersion.Rfc6455); Client.Opened += Client_Opened; Client.Error += Client_Error; Client.Closed += Client_Closed; Client.MessageReceived += Client_MessageReceived; Client.Open(); while (Client.State == WebSocketState.Connecting) { Thread.Sleep(100); } if (Client.State == WebSocketState.Open) { Client.Send("{\"jsonrpc\":\"2.0\",\"method\":\"user:update\",\"params\":{\"username\":\"" + Username + "\",\"user_seed\":\"1256e154283ea05b9538\",\"hide_bets_below\":\"0.0\",\"hide_other_bets\":false},\"id\":1}"); } else { finishedlogin(false); return false; } betrequest = (HttpWebRequest)HttpWebRequest.Create("https://www.bitdice.me/users/password"); betrequest.Method = "POST"; betrequest.CookieContainer = new CookieContainer(); string post = string.Format("user%5Bpassword%5D={0}&user%5Bpassword_confirmation%5D={0}", Password); username = Username; betrequest.ContentLength = post.Length; if (Prox != null) betrequest.Proxy = Prox; betrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8"; betrequest.CookieContainer.Add(new Cookie("_csn_session", cookie, "/", "bitdice.me")); betrequest.Headers.Add("X-CSRF-Token", csrf); using (var writer = new StreamWriter(betrequest.GetRequestStream())) { writer.Write(post); } EmitResponse = (HttpWebResponse)betrequest.GetResponse(); sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd(); cookie = EmitResponse.Cookies["_csn_session"].Value; betrequest = (HttpWebRequest)HttpWebRequest.Create("https://www.bitdice.me/"); if (Prox != null) betrequest.Proxy = Prox; betrequest.ContentType = "application/x-www-form-urlencoded; charset=UTF-8"; betrequest.CookieContainer = new CookieContainer(); betrequest.CookieContainer.Add(new Cookie("_csn_session", cookie, "/", "bitdice.me")); EmitResponse = (HttpWebResponse)betrequest.GetResponse(); sEmitResponse = new StreamReader(EmitResponse.GetResponseStream()).ReadToEnd(); getDeposit(sEmitResponse); getcsrf(sEmitResponse); cookie = EmitResponse.Cookies["_csn_session"].Value; getstream(sEmitResponse); getcsrf(sEmitResponse); getstream(sEmitResponse); if (Client != null) Client.Close(); headers = new List<KeyValuePair<string, string>>(); headers.Add(new KeyValuePair<string, string>("Cookie", "_csn_session=" + cookie)); Client = new WebSocket("wss://www.bitdice.me/stream/" + stream, "", null, headers, "dicebot", "http://bitdice.me", WebSocketVersion.Rfc6455); Client.Opened += Client_Opened; Client.Error += Client_Error; Client.Closed += Client_Closed; Client.MessageReceived += Client_MessageReceived; Client.Open(); while (Client.State == WebSocketState.Connecting) { Thread.Sleep(100); } finishedlogin(Client.State == WebSocketState.Open); return true; } catch { return false; } }
/// <summary> /// Asynchronously closes the WebSocket connection for the specified reason. /// </summary> /// <param name="reason">The reason.</param> protected override async Task CloseWebSocketAsyncCore(string reason) { if (!IsWebSocketOpen) { return; } Logger.Trace(Log("Closing web socket connection: {0}", reason)); bool result = false; Exception ex = null; var task = new Task <bool>(() => { if (ex != null) { throw ex; } return(result); }); EventHandler closedHandler = null; EventHandler <ErrorEventArgs> errorHandler = null; Action clearHandlers = () => { _socket.Closed -= closedHandler; _socket.Error -= errorHandler; }; bool handled = false; closedHandler = (s, e) => { if (!handled) { handled = true; clearHandlers(); handled = true; OnWebSocketClosed(s, e); result = true; task.Start(); } }; errorHandler = (s, e) => { if (!handled) { handled = true; clearHandlers(); if (e.Exception.ExceptionMeansConnectionTerminated()) { result = true; } else { ex = e.Exception; } task.Start(); } }; _socket.Closed += closedHandler; _socket.Error += errorHandler; UnsubscribeFromSocketEvents(); _socket.Close(reason); await task.ConfigureAwait(CaptureAsyncContext); }
public void ReconnectTest() { WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error); webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); for (var i = 0; i <2000; i++) { webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(5000)) Assert.Fail("Failed to Opened session ontime at round {0}", i); Assert.AreEqual(WebSocketState.Open, webSocketClient.State); webSocketClient.Close(); if (!m_CloseEvent.WaitOne(5000)) Assert.Fail("Failed to close session ontime"); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); } }
public void Close() { m_WebSocketClient.Close(); m_WebSocketClient = null; }
public void SendDataTest() { WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version); if (!webSocketClient.SupportBinary) return; webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.DataReceived += new EventHandler<DataReceivedEventArgs>(webSocketClient_DataReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(2000)) Assert.Fail("Failed to Opened session ontime"); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 10; i++) { sb.Append(Guid.NewGuid().ToString()); } string messageSource = sb.ToString(); Random rd = new Random(); for (int i = 0; i < 100; i++) { int startPos = rd.Next(0, messageSource.Length - 2); int endPos = rd.Next(startPos + 1, messageSource.Length - 1); string message = messageSource.Substring(startPos, endPos - startPos); Console.WriteLine("Client:" + message); var data = Encoding.UTF8.GetBytes(message); webSocketClient.Send(data, 0, data.Length); if (!m_MessageReceiveEvent.WaitOne(1000)) Assert.Fail("Cannot get response in time!"); Assert.AreEqual(message, m_CurrentMessage); } webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); }
public void ConnectionTest() { WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, Port), subProtocol: "basic", version: m_Version); webSocketClient.Error += new EventHandler<SuperSocket.ClientEngine.ErrorEventArgs>(webSocketClient_Error); //webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.MessageReceived += new EventHandler<MessageReceivedEventArgs>(webSocketClient_MessageReceived); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne()) Assert.Fail("Failed to Opened session ontime"); Assert.AreEqual(WebSocketState.Open, webSocketClient.State); webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); Assert.AreEqual(WebSocketState.Closed, webSocketClient.State); }
public void ConcurrentSendTest() { WebSocket webSocketClient = new WebSocket(string.Format("{0}:{1}/websocket", Host, m_WebSocketServer.Config.Port), "basic", m_Version); webSocketClient.AllowUnstrustedCertificate = true; webSocketClient.Opened += new EventHandler(webSocketClient_Opened); webSocketClient.Closed += new EventHandler(webSocketClient_Closed); webSocketClient.Open(); if (!m_OpenedEvent.WaitOne(2000)) Assert.Fail("Failed to Opened session ontime"); string[] lines = new string[100]; for (int i = 0; i < lines.Length; i++) { lines[i] = Guid.NewGuid().ToString(); } var messDict = lines.ToDictionary(l => l); webSocketClient.MessageReceived += (s, m) => { messDict.Remove(m.Message); Console.WriteLine("R: {0}", m.Message); }; Parallel.For(0, lines.Length, (i) => { webSocketClient.Send("ECHO " + lines[i]); }); int waitRound = 0; while (waitRound < 10) { if (messDict.Count <= 0) break; Thread.Sleep(500); waitRound++; } if (messDict.Count > 0) { Assert.Fail("Failed to receive message on time."); } webSocketClient.Close(); if (!m_CloseEvent.WaitOne(1000)) Assert.Fail("Failed to close session ontime"); }
public void Disconnect() { _ws?.Close(); _ws = null; }
public List<SniperInfo> FindAll() { List<SniperInfo> newSniperInfos = new List<SniperInfo>(); try { using (var client = new WebSocket(URL, "basic", WebSocketVersion.Rfc6455)) { client.MessageReceived += (s, e) => { try { var message = e.Message; var match = Regex.Match(message, @"(1?\d+)+\[""helo"",(2?.*)\]"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfos = GetJsonList(match.Groups[2].Value); if (sniperInfos != null && sniperInfos.Any()) { newSniperInfos.AddRange(sniperInfos); } } } else { match = Regex.Match(message, @"(1?\d+)+\[""poke"",(2?.*)\]"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfo = GetJson(match.Groups[2].Value); if (sniperInfo != null) { newSniperInfos.Add(sniperInfo); } } } } } catch (Exception ex) { Log.Debug("Error receiving message from PokemonGoIVClub", ex); } }; client.Open(); Thread.Sleep(Timeout); client.Close(); } } catch (Exception e) { Log.Warn("Received error from Pokezz. More info the logs"); Log.Debug("Received error from Pokezz: ", e); } return newSniperInfos; }
public void Close() { webSocketFeed.Close(); }
public List<SniperInfo> FindAll() { List<SniperInfo> newSniperInfos = new List<SniperInfo>(); try { string token = ""; using (var client = new HttpClient()) { // Use the HttpClient as usual. Any JS challenge will be solved automatically for you. var content = client.GetStringAsync(AuthUrl).Result; token = GetToken(content)?.token; } string URL = $"ws://188.165.224.208:49001/socket.io/?EIO=3&transport=websocket&token={token}"; using (var client = new WebSocket(URL, "basic", null, new List<KeyValuePair<string, string>>() {new KeyValuePair<string, string>("Referer","http://www.rarespawns.be/"), new KeyValuePair<string, string>("Host", "188.165.224.208:49001") }, "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36", "http://www.rarespawns.be", WebSocketVersion.Rfc6455, null)) { client.MessageReceived += (s, e) => { try { var message = e.Message; if (message == "40") { client.Send("40/pokes"); } var match = Regex.Match(message, @"(1?\d+)+.*\[""helo"",(2?.*)\]"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfos = GetJsonList(match.Groups[2].Value); if (sniperInfos != null && sniperInfos.Any()) { newSniperInfos.AddRange(sniperInfos); } } } else { match = Regex.Match(message, @"(1?\d+)+.*\[""poke"",(2?.*)\]"); if (match.Success) { if (match.Groups[1].Value == "42") { var sniperInfo = GetJson(match.Groups[2].Value); if (sniperInfo != null) { newSniperInfos.Add(sniperInfo); } } } } } catch (Exception ex) { Log.Debug("Error receiving message from RareSpawns", ex); } }; client.Open(); Thread.Sleep(Timeout); client.Close(); } } catch (Exception e) { Log.Warn("Received error from Pokezz. More info the logs"); Log.Debug("Received error from Pokezz: ", e); } return newSniperInfos; }
private void websocket_Opened(object sender, EventArgs e) { websocket.Send(this.data); websocket.Close(); }