public async Task SendLargeBinaryMessage(bool useNinja) { using (var server = new Server()) { server.StartListener(); // Create client WebSocket webSocket; if (useNinja) { var factory = new WebSocketClientFactory(); webSocket = await factory.ConnectAsync(server.Address, new WebSocketClientOptions(), CancellationToken.None); } else { var clientWebSocket = new ClientWebSocket(); await clientWebSocket.ConnectAsync(server.Address, CancellationToken.None); webSocket = clientWebSocket; } // Send large message byte[] message = new byte[10000]; new Random().NextBytes(message); await SendBinaryMessage(webSocket, message, 1024); // Close await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", CancellationToken.None); Assert.Single(server.ReceivedMessages); Assert.Equal(message, server.ReceivedMessages[0]); } }
public async Task Run() { var factory = new WebSocketClientFactory(); var uri = new Uri("ws://localhost:27416/chat"); using (WebSocket webSocket = await factory.ConnectAsync(uri)) { var pipe = new Pipe(); // receive loop Task readTask = Receive(webSocket, pipe.Writer); Task reading = ReadPipeAsync(webSocket, pipe.Reader); for (int i = 0; i < 10; i++) { // send a message await Send(webSocket); Console.ReadLine(); } // initiate the close handshake await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None); // wait for server to respond with a close frame await readTask; } }
async Task <string> sendrcv(Uri webSocketUri, string expression) { var factory = new WebSocketClientFactory(); using (WebSocket webSocket = await factory.ConnectAsync(webSocketUri)) { try { // receive loop var readTask = Receive(webSocket); // send a message await Send(webSocket, expression); // initiate the close handshake await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None); // wait for server to respond with a close frame List <string> returnedData = await readTask; return(String.Join("", returnedData)); } catch (WebSocketException) { return(null); } } }
/// <inheritdoc cref="ISocketAdapter.ConnectAsync"/> public async Task ConnectAsync(Uri uri, int timeout) { if (_webSocket != null && _webSocket.State == WebSocketState.Open) { // Already connected so we can return. return; } _cancellationSource = new CancellationTokenSource(); _uri = uri; IsConnecting = true; var clientFactory = new WebSocketClientFactory(); try { var cts = new CancellationTokenSource(TimeSpan.FromSeconds(timeout)); var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_cancellationSource.Token, cts.Token); _webSocket = await clientFactory.ConnectAsync(_uri, _options, linkedCts.Token).ConfigureAwait(false); _ = Task.Factory.StartNew(_ => ReceiveLoop(_webSocket, _cancellationSource.Token), TaskCreationOptions.LongRunning, _cancellationSource.Token); Connected?.Invoke(); IsConnected = true; } catch (Exception) { IsConnected = false; throw; } finally { IsConnecting = false; } }
static async Task Main(string[] args) { if (args.Length < 6) { return; } POCViewModel vm = null; var rnd = new Random(Guid.NewGuid().GetHashCode()); var clientName = ConfigData.Instance.ClientBaseName + rnd.Next(); var bbr = new BoundingBoxRequest(name: clientName, minLongitude: int.Parse(args[1]), minLatitude: int.Parse(args[3]), maxLongitude: int.Parse(args[2]), maxLatitude: int.Parse(args[4])); var factory = new WebSocketClientFactory(); var client = factory.Create(ConfigData.Instance.Hostname, ConfigData.Instance.Port, ConfigData.Instance.ClientType); if (await client.InitializeAsync()) { vm = new POCViewModel(client, clientName, bbr, args[0]); await vm.StartUpdatesListener(); } await Task.Delay(int.Parse(args[5])); if (vm != null) { vm.Dispose(); } Environment.Exit(0); }
public async void Connect(System.Uri uri) { var clientFactory = new WebSocketClientFactory(); cancellation = new CancellationTokenSource(); Connecting = true; try { using (WebSocket = await clientFactory.ConnectAsync(uri, ClientOptions, cancellation.Token)) { Connecting = false; ConnectionActive = true; Connected?.Invoke(); await Receive(WebSocket, cancellation.Token); } } catch (System.ObjectDisposedException) { // client closed Debug.Log("closed connection"); } catch (System.Exception ex) { Debug.LogError(ex); ReceivedError?.Invoke(ex); } finally { Disconnect(); } }
internal ParseLiveQueryClient(Uri hostUri, WebSocketClientFactory webSocketClientFactory, ISubscriptionFactory subscriptionFactory, ITaskQueue taskQueue) { _hostUri = hostUri; _applicationId = ParseClient.CurrentConfiguration.ApplicationId; _webSocketClientFactory = webSocketClientFactory; _webSocketClientCallback = new WebSocketClientCallback(this); _subscriptionFactory = subscriptionFactory; _taskQueue = taskQueue; }
internal ParseLiveQueryClient(Uri hostUri, WebSocketClientFactory webSocketClientFactory, ISubscriptionFactory subscriptionFactory, ITaskQueue taskQueue) { _hostUri = hostUri; _applicationId = ParseClient.Instance.Services.ServerConnectionData.ApplicationID; _webSocketClientFactory = webSocketClientFactory; _webSocketClientCallback = new WebSocketClientCallback(this); _subscriptionFactory = subscriptionFactory; _taskQueue = taskQueue; }
public async Task Connect(string ip) { if (client != null) { throw new Exception("Already connected to remote."); } var fac = new WebSocketClientFactory(); client = await fac.ConnectAsync(new Uri(ip)); }
public override async void DidFinishLaunching(NSNotification notification) { this.factory = new WebSocketClientFactory(); var uri = new Uri("ws://127.0.0.1:8080"); this.webSocket = await this.factory.ConnectAsync(uri); this.jsonRpc = new JsonRpc(new WebSocketMessageHandler(webSocket)); this.jsonRpc.StartListening(); var result = await jsonRpc.InvokeAsync <int>("Add", 5, 10); Console.WriteLine(result); }
public async void Connect(Uri uri) { // not if already started if (webSocket != null) { // paul: exceptions are better than silence ReceivedError?.Invoke(new Exception("Client already connected")); return; } this.uri = uri; // We are connecting from now until Connect succeeds or fails Connecting = true; var options = new WebSocketClientOptions() { NoDelay = true, KeepAliveInterval = TimeSpan.Zero, SecWebSocketProtocol = "binary" }; cancellation = new CancellationTokenSource(); var clientFactory = new WebSocketClientFactory(); try { using (webSocket = await clientFactory.ConnectAsync(uri, options, cancellation.Token)) { var token = cancellation.Token; IsConnected = true; Connecting = false; Connected?.Invoke(); await ReceiveLoop(webSocket, token); } } catch (ObjectDisposedException) { // No error, the client got closed } catch (Exception ex) { ReceivedError?.Invoke(ex); } finally { Disconnect(); Disconnected?.Invoke(); } }
public async Task SendLargeBinaryMessage(bool useNinja) { using (var server = new Server()) { server.StartListener(); // Create client WebSocket webSocket; if (useNinja) { var factory = new WebSocketClientFactory(); webSocket = await factory.ConnectAsync(server.Address, new WebSocketClientOptions(), CancellationToken.None); } else { var clientWebSocket = new ClientWebSocket(); await clientWebSocket.ConnectAsync(server.Address, CancellationToken.None); webSocket = clientWebSocket; } // Send large message byte[] message = new byte[10000]; new Random().NextBytes(message); await SendBinaryMessage(webSocket, message, 1024); // Close await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close", CancellationToken.None); // Wait for the server to receive our close message var stopwatch = Stopwatch.StartNew(); while (server.State == WebSocketState.Open) { await Task.Delay(5); if (stopwatch.Elapsed.TotalSeconds > 10) { throw new TimeoutException("Timeout expired after waiting for close handshake to complete"); } } Assert.Single(server.ReceivedMessages); Assert.Equal(message, server.ReceivedMessages[0]); } }
/// <inheritdoc cref="ISocketAdapter.Connect"/> public async void Connect(Uri uri, int timeout) { if (_webSocket != null) { ReceivedError?.Invoke(new SocketException((int)SocketError.IsConnected)); return; } _cancellationSource = new CancellationTokenSource(); _uri = uri; IsConnecting = true; var clientFactory = new WebSocketClientFactory(); try { var cts = new CancellationTokenSource(TimeSpan.FromSeconds(timeout)); var lcts = CancellationTokenSource.CreateLinkedTokenSource(_cancellationSource.Token, cts.Token); using (_webSocket = await clientFactory.ConnectAsync(_uri, _options, lcts.Token)) { IsConnected = true; IsConnecting = false; Connected?.Invoke(); await ReceiveLoop(_webSocket, _cancellationSource.Token); } } catch (TaskCanceledException) { // No error, the socket got closed via the cancellation signal. } catch (ObjectDisposedException) { // No error, the socket got closed. } catch (Exception e) { ReceivedError?.Invoke(e); } finally { Close(); Closed?.Invoke(); } }
public override SocketTasks StartClient() { string conUrl = Url; if (conUrl.EndsWith("/")) { conUrl = conUrl.Substring(0, conUrl.Length - 1); } conUrl += "/mlapi-connection"; client = WebSocketClientFactory.Create(conUrl); client.SetOnOpen(() => { clientEventQueue.Enqueue(new ClientEvent() { Type = NetEventType.Connect, Payload = new ArraySegment <byte>() }); }); client.SetOnClose((code) => { clientEventQueue.Enqueue(new ClientEvent() { Type = NetEventType.Disconnect, Payload = new ArraySegment <byte>() }); }); client.SetOnPayload((payload) => { clientEventQueue.Enqueue(new ClientEvent() { Type = NetEventType.Disconnect, Payload = payload }); }); client.Connect(); return(SocketTask.Done.AsTasks()); }
public async Task Run() { var factory = new WebSocketClientFactory(); using (WebSocket webSocket = await factory.ConnectAsync(new Uri("ws://localhost:27416/chat"))) { var readTask = Receive(webSocket); for (int i = 0; i < 10; i++) { var writeBuffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes($"Test{i}")); await webSocket.SendAsync(writeBuffer, WebSocketMessageType.Text, true, CancellationToken.None); } await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None); await readTask; } }
public async Task Run() { var factory = new WebSocketClientFactory(); WebSocketClientOptions options = new WebSocketClientOptions() { NoDelay = true, KeepAliveInterval = TimeSpan.Zero }; using (_webSocket = await factory.ConnectAsync(_uri, options)) { var source = new CancellationTokenSource(); _token = source.Token; Random rand = new Random(_seed); _expectedValues = new byte[50][]; for (int i = 0; i < _expectedValues.Length; i++) { int numBytes = rand.Next(_minNumBytesPerMessage, _maxNumBytesPerMessage); byte[] bytes = new byte[numBytes]; rand.NextBytes(bytes); _expectedValues[i] = bytes; } Task recTask = Task.Run(ReceiveLoop); byte[] sendBuffer = new byte[_maxNumBytesPerMessage]; for (int i = 0; i < _numItems; i++) { int index = i % _expectedValues.Length; byte[] bytes = _expectedValues[index]; Buffer.BlockCopy(bytes, 0, sendBuffer, 0, bytes.Length); ArraySegment <byte> buffer = new ArraySegment <byte>(sendBuffer, 0, bytes.Length); await _webSocket.SendAsync(buffer, WebSocketMessageType.Binary, true, source.Token); } await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "So long and thanks for all the bits", source.Token); recTask.Wait(); } }
public override async Task <IConnection> ConnectAsync(Uri uri) { var options = new WebSocketClientOptions { NoDelay = true, KeepAliveInterval = TimeSpan.Zero, SecWebSocketProtocol = "binary" }; if (uri.IsDefaultPort) { var builder = new UriBuilder(uri) { Port = Port }; uri = builder.Uri; } var clientFactory = new WebSocketClientFactory(); WebSocket webSocket = await clientFactory.ConnectAsync(uri, options); return(new WebsocketConnection(webSocket)); }
/// <summary> /// Connect to Home Assistant /// </summary> /// <param name="host">The host name</param> /// <param name="port">Network port</param> /// <param name="ssl">Set true to use ssl</param> /// <param name="token">The access token to use</param> /// <param name="websocketPath">The relative websocket path to use connecting</param> /// <param name="cancelToken">Cancellation token</param> public static async Task <IHomeAssistantConnection> ConnectClientAsync(string host, int port, bool ssl, string token, string websocketPath, CancellationToken cancelToken) { var loggerFactory = LoggerFactory.Create(b => b.AddConsole()); var loggerConnect = loggerFactory.CreateLogger <IHomeAssistantConnection>(); var loggerClient = loggerFactory.CreateLogger <IHomeAssistantClient>(); var loggerResultMessageHandler = loggerFactory.CreateLogger <ResultMessageHandler>(); var settings = new HomeAssistantSettings { Host = host, Port = port, Ssl = ssl, Token = token }; var optionsSettings = Options.Create(settings); var apiManager = new HomeAssistantApiManager(optionsSettings, new HttpClient()); var connectionFactory = new HomeAssistantConnectionFactory(loggerConnect, apiManager); var pipeLineFactory = new WebSocketClientTransportPipelineFactory(); var websocketClientFactory = new WebSocketClientFactory(Options.Create(settings)); var client = new HomeAssistantClient(loggerClient, websocketClientFactory, pipeLineFactory, connectionFactory); return(await client.ConnectAsync(host, port, ssl, token, websocketPath, cancelToken).ConfigureAwait(false)); }
static async Task RunClient() { var factory = new WebSocketClientFactory(); var uri = new Uri("ws://localhost:27416/chat"); using (WebSocket webSocket = await factory.ConnectAsync(uri)) { var jsonRpc = new JsonRpc(new WebSocketMessageHandler(webSocket)); jsonRpc.StartListening(); EntityServiceResult result = await CampaginServiceGetCountRequest.MakeCall(jsonRpc); Console.WriteLine(result.Result.ToString()); result = await CampaginServiceGetEntityRequest.MakeCall(jsonRpc, 0, 200, 1, "CampaignName"); Console.WriteLine(result.Result.ToString()); Console.ReadLine(); // initiate the close handshake await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None); } }
const int BUFFER_SIZE = 1 * 1024 * 1024 * 1024; // 1GB public async Task Run() { var factory = new WebSocketClientFactory(); var uri = new Uri("ws://localhost:27416/chat"); var options = new WebSocketClientOptions() { KeepAliveInterval = TimeSpan.FromMilliseconds(500) }; using (WebSocket webSocket = await factory.ConnectAsync(uri, options)) { // receive loop Task readTask = Receive(webSocket); // send a message await Send(webSocket); // initiate the close handshake await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None); // wait for server to respond with a close frame await readTask; } }
public ParseLiveQueryClient(WebSocketClientFactory webSocketClientFactory) : this(GetDefaultUri(), webSocketClientFactory) { }
public ParseLiveQueryClient(Uri hostUri, WebSocketClientFactory webSocketClientFactory) : this(hostUri, webSocketClientFactory, new SubscriptionFactory(), new TaskQueueWrapper()) { }