public virtual Stream Connect(Uri uri, bool requireAuthentication) { // IIS starts python.exe processes lazily on the first incoming request, and will terminate them after a period // of inactivity, making it impossible to attach. So before trying to connect to the debugger, "ping" the website // via HTTP to ensure that we have something to connect to. try { var httpRequest = WebRequest.Create(new UriBuilder(uri) { Scheme = "http", Port = -1, Path = "/" }.Uri); httpRequest.Method = WebRequestMethods.Http.Head; httpRequest.Timeout = 5000; httpRequest.GetResponse().Dispose(); } catch (WebException) { // If it fails or times out, just go ahead and try to connect anyway, and rely on normal error reporting path. } var webSocket = new ClientWebSocket(); try { webSocket.ConnectAsync(uri, CancellationToken.None).GetAwaiter().GetResult(); var stream = new WebSocketStream(webSocket, ownsSocket: true); webSocket = null; return stream; } catch (WebSocketException ex) { throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex); } catch (IOException ex) { throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex); } catch (PlatformNotSupportedException ex) { throw new ConnectionException(ConnErrorMessages.RemoteUnsupportedTransport, ex); } finally { if (webSocket != null) { webSocket.Dispose(); } } }
public async void ConnectAndStartReceivingToWebSocket() { ClientWebSocket webSocket = null; var uncontext = new Uri(_wsLiteratureUncontextCom); try { webSocket = new ClientWebSocket(); await webSocket.ConnectAsync(uncontext, CancellationToken.None); await Receive(webSocket); } catch (Exception ex) { Console.WriteLine("Exception: {0}", ex); } finally { if (webSocket != null) { webSocket.Dispose(); UncontextedData.OnCompleted(); } Console.WriteLine("Closed websocket."); } }
public void BasicRoundTrip() { var serializer = new JsonCommonSerializer(); var port = new Random().Next(6000, 60000); var options = new WebSocketListenerOptions(); options.SubProtocols = new[] { "SignalR" }; var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options); var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener); listener.Standards.RegisterStandard(rfc6455); var serverTransport = listener.GenerateTransportSource(); var serverRouter = new DefaultMessageRouter(serverTransport, serializer); serverRouter.AddService<IMyService>(new MyService()); listener.Start(); var client = new ClientWebSocket(); client.Options.AddSubProtocol("SignalR"); var clientTransport = client.GenerateTransportSource(); var clientRouter = new DefaultMessageRouter(clientTransport, serializer); var proxy = clientRouter.AddInterface<IMyService>(); client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait(); var result = proxy.Add(3, 4).Result; Assert.Equal(7, result); clientRouter.Dispose(); clientTransport.Dispose(); client.Dispose(); serverRouter.Dispose(); serverTransport.Dispose(); listener.Dispose(); }
public WebSocketWrapper(string uri) { _ws = new ClientWebSocket(); _ws.Options.KeepAliveInterval = TimeSpan.FromSeconds(20); _uri = new Uri(uri); _cancellationToken = _cancellationTokenSource.Token; }
public static async Task RunSample() { ClientWebSocket websocket = new ClientWebSocket(); string url = "ws://localhost:7000/"; Console.WriteLine("Connecting to: " + url); await websocket.ConnectAsync(new Uri(url), CancellationToken.None); int seed = 20000; Task[] taskList = new Task[seed]; Stopwatch sw = new Stopwatch(); sw.Restart(); for (var i = 0; i < seed; i++) { //taskList[i] = Send(websocket); await Send(websocket); } //Task.WaitAll(taskList); sw.Stop(); Console.WriteLine("seed:{0}, time:{1}", seed, sw.ElapsedMilliseconds); //if (result.CloseStatus.HasValue) //{ // Console.WriteLine("Closed; Status: " + result.CloseStatus + ", " + result.CloseStatusDescription); //} //else //{ // Console.WriteLine("Received message: " + Encoding.UTF8.GetString(incomingData, 0, result.Count)); //} }
public void BasicRoundTrip() { var serializer = new JsonCommonSerializer(); var server = new HttpListener(); server.Prefixes.Add("http://localhost:20000/"); server.Start(); var serverTransport = server.GenerateTransportSource(); var serverRouter = new DefaultMessageRouter(serverTransport, serializer); serverRouter.AddService<IMyService>(new MyService()); var client = new ClientWebSocket(); client.Options.SetBuffer(8192, 8192); var clientTransport = client.GenerateTransportSource(); var clientRouter = new DefaultMessageRouter(clientTransport, serializer); var proxy = clientRouter.AddInterface<IMyService>(); client.ConnectAsync(new Uri("ws://localhost:20000/"), CancellationToken.None).Wait(); var result = proxy.Add(3, 4).Result; Assert.Equal(7, result); clientRouter.Dispose(); clientTransport.Dispose(); client.Dispose(); serverRouter.Dispose(); serverTransport.Dispose(); server.Stop(); server.Close(); }
public static async Task Connect(string uri) { ClientWebSocket webSocket = null; try { webSocket = new ClientWebSocket(); await webSocket.ConnectAsync(new Uri(uri), CancellationToken.None); await Task.WhenAll(Receive(webSocket), Send(webSocket)); } catch (Exception ex) { Console.WriteLine("Exception: {0}", ex); } finally { if (webSocket != null) webSocket.Dispose(); Console.WriteLine(); lock (consoleLock) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("WebSocket closed."); Console.ResetColor(); } } }
public async Task WebsocketBasic(HostType hostType) { using (ApplicationDeployer deployer = new ApplicationDeployer()) { string applicationUrl = deployer.Deploy(hostType, WebsocketBasicConfiguration); using (var client = new ClientWebSocket()) { await client.ConnectAsync(new Uri(applicationUrl.Replace("http://", "ws://")), CancellationToken.None); var receiveBody = new byte[100]; for (int i = 0; i < 4; i++) { var message = "Message " + i.ToString(); byte[] sendBody = Encoding.UTF8.GetBytes(message); await client.SendAsync(new ArraySegment<byte>(sendBody), WebSocketMessageType.Text, true, CancellationToken.None); var receiveResult = await client.ReceiveAsync(new ArraySegment<byte>(receiveBody), CancellationToken.None); Assert.Equal(WebSocketMessageType.Text, receiveResult.MessageType); Assert.True(receiveResult.EndOfMessage); Assert.Equal(sendBody.Length, receiveResult.Count); Assert.Equal(message, Encoding.UTF8.GetString(receiveBody, 0, receiveResult.Count)); } } } }
public static async Task RunSample() { ClientWebSocket websocket = new ClientWebSocket(); string url = "ws://localhost:5000/"; Console.WriteLine("Connecting to: " + url); await websocket.ConnectAsync(new Uri(url), CancellationToken.None); string message = "Hello World"; Console.WriteLine("Sending message: " + message); byte[] messageBytes = Encoding.UTF8.GetBytes(message); await websocket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None); byte[] incomingData = new byte[1024]; WebSocketReceiveResult result = await websocket.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None); if (result.CloseStatus.HasValue) { Console.WriteLine("Closed; Status: " + result.CloseStatus + ", " + result.CloseStatusDescription); } else { Console.WriteLine("Received message: " + Encoding.UTF8.GetString(incomingData, 0, result.Count)); } }
public async Task ReadWriteTest() { var websocket = new ClientWebSocket(); // Set SubProtocol to AMQPWSB10 websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Amqpwsb10); Uri uri = new Uri("ws://" + IotHubName + ":" + Port + WebSocketConstants.UriSuffix); await websocket.ConnectAsync(uri, CancellationToken.None); clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null); // Test Write API var args = new TransportAsyncCallbackArgs(); args.CompletedCallback = onWriteOperationComplete; args.SetBuffer(byteArray, 0, byteArray.Length); clientWebSocketTransport.WriteAsync(args); // Test Read API args.CompletedCallback = onReadOperationComplete; if (clientWebSocketTransport.ReadAsync(args)) { while (!readComplete) { Thread.Sleep(TimeSpan.FromSeconds(1)); } } // Once Read operation is complete, close websocket transport // Test Close API await clientWebSocketTransport.CloseAsync(TimeSpan.FromSeconds(30)); }
public void Setup () { listener = new HttpListener (); listener.Prefixes.Add ("http://localhost:" + Port + "/"); listener.Start (); socket = new ClientWebSocket (); }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="options"></param> /// <exception cref="TimeoutException"></exception> /// <exception cref="WebSocketException"></exception> /// <returns></returns> public async Task ConnectAsync(Uri uri) { //#if NET45 //#elif NETSTANDARD2_0 //#endif //if (_io.Options.Proxy != null) //{ // _ws.Options.Proxy = _io.Options.Proxy; //} if (_ws != null) { _ws.Dispose(); } _ws = new System.Net.WebSockets.ClientWebSocket(); Options = _ws.Options; _wsWorkTokenSource = new CancellationTokenSource(); var wsConnectionTokenSource = new CancellationTokenSource(_io.Options.ConnectionTimeout); try { await _ws.ConnectAsync(uri, wsConnectionTokenSource.Token); await Task.Factory.StartNew(ListenAsync); await Task.Factory.StartNew(ListenStateAsync); } catch (TaskCanceledException) { throw new TimeoutException(); } }
internal async Task<IAsyncTransport> ConnectAsync(Address address, Action<ClientWebSocketOptions> options) { Uri uri = new UriBuilder() { Scheme = address.Scheme, Port = GetDefaultPort(address.Scheme, address.Port), Host = address.Host, Path = address.Path }.Uri; ClientWebSocket cws = new ClientWebSocket(); cws.Options.AddSubProtocol(WebSocketSubProtocol); if (options != null) { options(cws.Options); } await cws.ConnectAsync(uri, CancellationToken.None); if (cws.SubProtocol != WebSocketSubProtocol) { cws.Abort(); throw new NotSupportedException( string.Format( CultureInfo.InvariantCulture, "WebSocket SubProtocol used by the host is not the same that was requested: {0}", cws.SubProtocol ?? "<null>")); } this.webSocket = cws; return this; }
public async void TestConnectWebSocket() { if (TestHelper.IsMono) { Assert.Inconclusive("Mono doesn't have support to WebSockets"); } Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule"); Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler"); var clientSocket = new ClientWebSocket(); var ct = new CancellationTokenSource(); await clientSocket.ConnectAsync(new Uri(Resources.WsServerAddress + "/test"), ct.Token); Assert.AreEqual(clientSocket.State, WebSocketState.Open, "Connection is open"); var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA")); var buffer = new ArraySegment<byte>(new byte[1024]); await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token); var result = await clientSocket.ReceiveAsync(buffer, ct.Token); Assert.IsTrue(result.EndOfMessage); Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME"); }
private void RefreshInternal(string debuggerUrl) { if (string.IsNullOrEmpty(debuggerUrl)) return; ClientWebSocket connection = new ClientWebSocket(); connection.ConnectAsync(new Uri(debuggerUrl), _token).Wait(); PageReloadRequest request = new PageReloadRequest(); string rawRequest = request.ToJson(); var data = new ArraySegment<byte>(Encoding.UTF8.GetBytes(rawRequest)); connection.SendAsync(data, WebSocketMessageType.Text, true, _token).Wait(); var buffer = new ArraySegment<byte>(new byte[1024]); Task<WebSocketReceiveResult> receiveAsync = connection.ReceiveAsync(buffer, _token); receiveAsync.Wait(); string rawResponse = Encoding.UTF8.GetString(buffer.Array, 0, receiveAsync.Result.Count); DebugProtocolResponse response = rawResponse.FromJson<DebugProtocolResponse>(); if (null != response.Error) { Trace.TraceWarning("Browser returned an error as a response to reload request: {0}", response.Error.Message); } connection.Dispose(); }
public WebSocketTransport() { this._socket = new ClientWebSocket(); this._socket.Options.AddSubProtocol("wamp"); this._cts = new CancellationTokenSource(); this._serializer = new DapperWare.Serialization.JsonSerializer(); }
public async Task ConnectAsync(Uri uri, WebSocketConnectionOptions options) { if (_ws != null) { _ws.Dispose(); } //ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, errors) => //{ // //// local dev, just approve all certs // //if (development) return true; // //return errors == SslPolicyErrors.None; // return true; //}; _ws = CreateClient(); //var cert = new X509Certificate2(@"C:\Users\41608\Downloads\cert\client1-crt.pem"); //var privateKey = cert.PrivateKey as RSACryptoServiceProvider; //privateKey.en //_ws.Options.ClientCertificates.Add(cert); _connectionToken = new CancellationTokenSource(); await _ws.ConnectAsync(uri, _connectionToken.Token); await Task.Factory.StartNew(ListenAsync, _connectionToken.Token); await Task.Factory.StartNew(ListenStateAsync, _connectionToken.Token); }
protected override void Initialize(IMessageSerializer messageSerializer) { try { this.socket = new ClientWebSocket(); this.socket.ConnectAsync(new Uri(serverUrl), CancellationToken.None).Wait(); } catch (AggregateException ex) { var wsException= ex.InnerExceptions.FirstOrDefault() as WebSocketException; if (wsException != null) { Logger.Write(LogLevel.Warning, string.Format("Failed to connect to WebSocket server. Error was '{0}'", wsException.Message)); } throw; } this.inputStream = new ClientWebSocketStream(socket); this.outputStream = new ClientWebSocketStream(socket); // Set up the message reader and writer this.MessageReader = new MessageReader( this.inputStream, messageSerializer); this.MessageWriter = new MessageWriter( this.outputStream, messageSerializer); }
/// <summary> /// Initializes a new instance of the <see cref="WebSocketConnection"/> class. /// </summary> /// <param name="serverUri"> /// The server uri. /// </param> public WebSocketConnection(Uri serverUri) { this.serverUri = serverUri; this.client = new ClientWebSocket(); this.sendQueue = new BlockingCollection<string>(); this.buffer = new ArraySegment<byte>(new byte[1024]); }
public async Task ClientWebSocketChannelReadWithoutConnectTest() { var websocket = new ClientWebSocket(); clientWebSocketChannel = new ClientWebSocketChannel(null, websocket); var threadLoop = new SingleThreadEventLoop("MQTTExecutionThread", TimeSpan.FromSeconds(1)); await threadLoop.RegisterAsync(clientWebSocketChannel); clientWebSocketChannel.Read(); }
public WsCommunicationClient(string baseAddress) { Logger.Debug("ctor: {0}", baseAddress); this.clientWebSocket = new ClientWebSocket(); this.BaseAddress = baseAddress; }
protected WebSocketWrapper(string uri) { System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12; _ws = new ClientWebSocket(); _ws.Options.KeepAliveInterval = TimeSpan.FromSeconds(20); _uri = new Uri(uri); _cancellationToken = _cancellationTokenSource.Token; }
public async Task ListenAsync() { var socket = new ClientWebSocket(); await socket.ConnectAsync(new Uri(ServerUrl.Replace("http://", "ws://")), CancellationToken.None); // listen for updates await Receive(socket); }
public Task Disconnect() { string ignored; while (_sendQueue.TryDequeue(out ignored)) { } _webSocket.Dispose(); _webSocket = new ClientWebSocket(); return TaskHelper.CompletedTask; }
public ClientWebSocketTransport(ClientWebSocket webSocket, EndPoint localEndpoint, EndPoint remoteEndpoint) : base("clientwebsocket") { this.webSocket = webSocket; this.localEndPoint = localEndpoint; this.remoteEndPoint = remoteEndpoint; this.writeCancellationTokenSource = new CancellationTokenSource(); }
public void ClientWebSocketTransportWriteWithoutConnectTest() { var websocket = new ClientWebSocket(); var clientWebSocketTransport = new ClientWebSocketTransport(websocket, null, null); var args = new TransportAsyncCallbackArgs(); args.SetBuffer(byteArray, 0, byteArray.Length); clientWebSocketTransport.WriteAsync(args); }
public Task Disconnect() { string ignored; while (_sendQueue.TryDequeue(out ignored)) { } _webSocket = null; return TaskHelper.CompletedTask; }
public void ConnectPusher() { _ws = new ClientWebSocket(); _ws.ConnectAsync(new Uri("wss://ws.pusherapp.com/app/de504dc5763aeef9ff52?client=PC-Orbit&version=1.0&protocol=7"), _source.Token).Wait(); _connected = true; ThreadingHelper.Thread(OnReceive).Launch(); }
protected override void Main() { if (Environment.OSVersion.Version < new Version(6, 2)) { TraceError(Text.LabRequiresWindows8OrHigher); return; } const int port = 5494; string subProtocol = GetType().Name; var userMessages = new BehaviorSubject<string>(null); var client = new ClientWebSocket(); client.Options.AddSubProtocol(subProtocol); using (client) using (var cancel = new CancellationDisposable()) using (ObservableHttpListener .StartWebSockets(new IPEndPoint(IPAddress.Loopback, port), subProtocol) .Subscribe( async request => { using (var socket = request.WebSocket) { try { var message = await ReceiveMessageAsync(socket, cancel.Token); await SendMessageAsync("You sent \"" + message + "\"", socket, cancel.Token); await ReceiveCloseMessageAsync(socket, cancel.Token); } catch (OperationCanceledException) { } } }, TraceError)) using ((from _ in client.ConnectAsync(new Uri("ws://localhost:" + port), cancel.Token).ToObservable() .Do(_ => TraceLine(Environment.NewLine + "(Connected to host on sub-protocol \"{0}\")", client.SubProtocol)) from message in userMessages.Where(m => m != null).Take(1) from __ in SendMessageAsync(message, client, cancel.Token).ToObservable() from response in ReceiveMessageAsync(client, cancel.Token).ToObservable() .Do(___ => client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done", cancel.Token)) select response) .Subscribe( response => TraceLine("Response: {0}", response), TraceError, () => TraceLine("{0}: {1}", Text.Client, Text.Done))) { userMessages.OnNext(UserInput("{0}> ", Instructions.EnterAMessage)); TraceStatus(Instructions.PressAnyKeyToCancel); WaitForKey(); } }
public void ClientWebSocketTransportReadTest() { var websocket = new ClientWebSocket(); var clientWebSocketTransport = new ClientWebSocketTransport(websocket, IotHubName, null, null); TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs(); byte[] byteArray = new byte[10]; args.SetBuffer(byteArray, 0, 10); clientWebSocketTransport.ReadAsync(args); }
public async Task Connect(string host, CancellationToken cancelToken) { _webSocket = new WebSocketClient(); _webSocket.Options.Proxy = null; _webSocket.Options.SetRequestHeader("User-Agent", _config.UserAgent); _webSocket.Options.KeepAliveInterval = TimeSpan.Zero; _tempTask = await _webSocket.ConnectAsync(new Uri(host), cancelToken)//.ConfigureAwait(false); .ContinueWith(t => ReceiveAsync(cancelToken)).ConfigureAwait(false); //TODO: ContinueWith is a temporary hack, may be a bug related to https://github.com/dotnet/corefx/issues/4429 }
public async Task ConnectAsync(Uri uri, WebSocketConnectionOptions options) { _ws = new System.Net.WebSockets.ClientWebSocket(); _connectionToken = new CancellationTokenSource(); await _ws.ConnectAsync(uri, _connectionToken.Token); await Task.Factory.StartNew(ListenAsync, _connectionToken.Token); await Task.Factory.StartNew(ListenStateAsync, _connectionToken.Token); }
public Task Disconnect() { string ignored; while (_sendQueue.TryDequeue(out ignored)) { } _webSocket = null; return(TaskHelper.CompletedTask); }
static bool CheckManagedWebSocketRequired() { try { using (var clientWebSocket = new System.Net.WebSockets.ClientWebSocket()) { return(false); } } catch (PlatformNotSupportedException) { return(true); } }
/// <summary> /// <c>overrideOnOk</c> will be called before the regular onOk has been processed, allowing customization of what happens /// on that response. Implement this method in a partial class to enable this behavior /// </summary> /// <param name="responseMessage">the raw response message as an global::System.Net.Http.HttpResponseMessage.</param> /// <param name="response">the body result as a <see cref="Microsoft.Azure.PowerShell.Cmdlets.ContainerInstance.Models.Api20210901.IContainerExecResponse" /// /> from the remote call</param> /// <param name="returnNow">/// Determines if the rest of the onOk method should be processed, or if the method should return /// immediately (set to true to skip further processing )</param> partial void overrideOnOk(global::System.Net.Http.HttpResponseMessage responseMessage, global::System.Threading.Tasks.Task <Microsoft.Azure.PowerShell.Cmdlets.ContainerInstance.Models.Api20210901.IContainerExecResponse> response, ref global::System.Threading.Tasks.Task <bool> returnNow) { var containerExecResponse = response.ConfigureAwait(false).GetAwaiter().GetResult(); socket = new System.Net.WebSockets.ClientWebSocket(); // Connect websocket socket.ConnectAsync(new System.Uri(containerExecResponse.WebSocketUri), _cancellationTokenSource.Token).ConfigureAwait(false).GetAwaiter().GetResult(); socket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(containerExecResponse.Password)), WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false).GetAwaiter().GetResult(); var receiver = PullResponse(); var sender = PushCommand(); Task.WaitAll(sender, receiver); returnNow = global::System.Threading.Tasks.Task.FromResult(true); }
public async Task ConnectAsync(Uri uri, WebSocketConnectionOptions options) { if (_ws != null) { _ws.Dispose(); } _ws = new System.Net.WebSockets.ClientWebSocket(); //var cert = new X509Certificate2(@"C:\Users\41608\Downloads\cert\client1-crt.pem"); //var privateKey = cert.PrivateKey as RSACryptoServiceProvider; //privateKey.en //_ws.Options.ClientCertificates.Add(cert); _connectionToken = new CancellationTokenSource(); await _ws.ConnectAsync(uri, _connectionToken.Token); await Task.Factory.StartNew(ListenAsync, _connectionToken.Token); await Task.Factory.StartNew(ListenStateAsync, _connectionToken.Token); }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="options"></param> /// <exception cref="TimeoutException"></exception> /// <exception cref="WebSocketException"></exception> /// <returns></returns> public async Task ConnectAsync(Uri uri) { DisposeWebSocketIfNotNull(); _ws = new System.Net.WebSockets.ClientWebSocket(); Config?.Invoke(_ws.Options); var wsConnectionTokenSource = new CancellationTokenSource(ConnectionTimeout); try { await _ws.ConnectAsync(uri, wsConnectionTokenSource.Token); DisposeListenTokenIfNotNull(); _listenToken = new CancellationTokenSource(); _ = ListenAsync(_listenToken.Token); } catch (TaskCanceledException) { throw new TimeoutException(); } }
// internal API ///////////////////////////////////////////////////////////// internal WebSocket(Uri uri, WebSocketListener listener) { bool ignoreCase = true; this.uri = uri; this.listener = listener; this.protocols = new ArrayList(); if ((String.Compare("ws", uri.Scheme, ignoreCase) != 0) && (String.Compare("wss", uri.Scheme, ignoreCase) != 0)) { throw new Exception("URI scheme must be 'ws' or 'wss'"); } clientWebSocket = new ClientWebSocket(); options = clientWebSocket.Options; // turn off pongs from client to server. options.KeepAliveInterval = new System.TimeSpan(0); }
/// <summary> /// Connect to the specified host, handshake and prepare the listening task. /// </summary> /// <param name="host">The URI of the host, usually something like ws://host:port</param> /// <param name="timeout">The maximum timeout in milliseconds for the function to execute. Will raise exception when timeout is reached.</param> /// <returns></returns> internal async System.Threading.Tasks.Task Connect(string host, int timeout) { try { System.Uri uri = new System.Uri(host); using (var cts = new System.Threading.CancellationTokenSource()) { // Connect if (ws == null) { ws = new System.Net.WebSockets.ClientWebSocket(); } await ws.ConnectAsync(uri, cts.Token); } { // [HELLO, Realm|uri, Details|dict] await Send($"[{(int)Messages.HELLO},\"realm1\"]", timeout); } StartListen(); { // Should receive the WELCOME Response response = await ReceiveExpect(Messages.WELCOME, 0, timeout); sessionId = response.ContextSpecificResultId; } } catch (System.Net.WebSockets.WebSocketException e) { ws.Dispose(); ws = new System.Net.WebSockets.ClientWebSocket(); throw new ErrorException(e.ToString()); } catch (System.Exception e) { throw new ErrorException(e.ToString()); } }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="options"></param> /// <exception cref="TimeoutException"></exception> /// <exception cref="WebSocketException"></exception> /// <returns></returns> public async Task ConnectAsync(Uri uri) { if (_ws != null) { _ws.Dispose(); } _ws = new System.Net.WebSockets.ClientWebSocket(); Config?.Invoke(_ws.Options); _wsWorkTokenSource = new CancellationTokenSource(); var wsConnectionTokenSource = new CancellationTokenSource(_io.Options.ConnectionTimeout); try { await _ws.ConnectAsync(uri, wsConnectionTokenSource.Token); _ = Task.Run(ListenAsync); } catch (TaskCanceledException) { throw new TimeoutException(); } }
public static async Task ConnectAsync(this ClientWebSocket client, string uri) { await client.ConnectAsync(new Uri(uri), CancellationToken.None); }
public TClientWebSocket CreateClient(ClientWebSocket client) { client = client ?? throw new ArgumentNullException(nameof(client)); return((TClientWebSocket)_cache.Activator(_services, new object[] { client })); }
public WebSocketClient() { _clientWebSocket = new System.Net.WebSockets.ClientWebSocket(); //_clientWebSocket.SubProtocol = "arraybuffer"; }
public FrameworkClientWebSocket(System.Net.WebSockets.ClientWebSocket client) { this.client = client; this.Options = new FrameworkClientWebSocketOptions(this.client.Options); }
public ClientWebSocket(System.Net.WebSockets.ClientWebSocket socket) { mSocket = socket; }
public async Task TestConnectWebSocket() { var wsUrl = Resources.WsServerAddress + "test"; Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule"); Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler"); #if NET46 var clientSocket = new ClientWebSocket(); var ct = new CancellationTokenSource(); await clientSocket.ConnectAsync(new Uri(wsUrl), ct.Token); Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open"); var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA")); var buffer = new ArraySegment<byte>(new byte[1024]); await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token); var result = await clientSocket.ReceiveAsync(buffer, ct.Token); Assert.IsTrue(result.EndOfMessage, "End of message is true"); Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME", "Final message is WELCOME"); #else var clientSocket = new WebSocket(wsUrl); clientSocket.Connect(); Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open"); clientSocket.Send("HOLA"); await Task.Delay(100); #endif }