public void Receive() { WebSocketClient ws = new WebSocketClient(new Uri("ws://localhost:8080/YASO/chat")); ManualResetEvent receiveEvent = new ManualResetEvent(false); ws.OnMessage += (s, e) => { receiveEvent.Set(); }; ws.Connect(); ws.Send("login: User1"); bool received = receiveEvent.WaitOne(TimeSpan.FromSeconds(2)); Assert.IsTrue(received); receiveEvent.Close(); ws.Close(); }
public void UsageTest() { var resetEvent = new ManualResetEvent(false); var location = new Uri("ws://echo.websocket.org"); var client = new WebSocketClient(location); client.OnOpen = () => Debug.WriteLine("Connection Open"); client.OnClose = () => { Debug.WriteLine("Connection Closed"); resetEvent.Set(); }; client.OnError = _ => Debug.WriteLine("error " + _); client.OnMessage = m => { Debug.WriteLine(m); client.CloseAsync(); }; client.Connect(); client.Send("Hello!"); resetEvent.WaitOne(); }
public WebsocketService() { connection = new WebSocketClient(); connection.Closed += OnWebsocketClosed; connection.Error += OnWebsocketError; connection.MessageReceived += OnWebsocketReceived; connection.AutoSendPongResponse = false; }
async void Init(){ Client = new WebSocketClient (); Client.MessageReceived += OnMessage; await Client.OpenAsync("ws://echo.websocket.org"); OnMessage("Client connected."); }
private async Task TestWebsocketPortable() { var client = new WebSocketClient(); client.Opened += websocket_Opened; client.Closed += websocket_Closed; client.MessageReceived += websocket_MessageReceived; client.Error += Client_Error; await client.OpenAsync("ws://echo.websocket.org"); await client.SendAsync("Hello World"); await client.SendAsync("Hello World2"); await Task.Delay(1000); await client.CloseAsync(); await Task.Delay(100); Debug.WriteLine("TestWebsocketPortable"); }
public async Task Connect_Success() { using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); var webSocket = await context.WebSockets.AcceptWebSocketAsync(); })) { var client = new WebSocketClient(); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { } } }
private async Task TestWebsocketPortable() { var client = new WebSocketClient(); client.Opened += websocket_Opened; client.Closed += websocket_Closed; client.MessageReceived += websocket_MessageReceived; //Never Ending await client.OpenAsync("ws://echo.websocket.org"); await client.SendAsync("Hello World"); await client.SendAsync("Hello World2"); Debug.WriteLine("TestWebsocketPortable"); }
private static void ResetClient() { if (Client != null) { Client.Disconnect(); } var clientOptions = new ClientOptions { MessagesAllowedInPeriod = 750, ThrottlingPeriod = TimeSpan.FromSeconds(30) }; WebSocketClient customClient = new WebSocketClient(clientOptions); Client = new TwitchClient(customClient); }
protected bool createSocket() { if (string.IsNullOrEmpty (host.Text)) { logText ("No host name"); return false; } try { ws = new WebSocketClient (host.Text) { OnReceive = OnReceive, OnDisconnect = OnDisconnect }; return true; } catch (System.Exception e) { logText ("Not a valid host name: " + e.Message); return false; } }
static void Main(string[] args) { var firstArg = args.FirstOrDefault(); if (string.IsNullOrWhiteSpace(firstArg)) { Console.WriteLine("Select a client:"); Console.WriteLine(""); Console.WriteLine("gg = destiny.gg"); Console.WriteLine("ggl = destiny.gg listening only"); Console.WriteLine("t = twitch.tv"); Console.WriteLine("tl = twitch.tv listening only"); Console.WriteLine("s = sample client"); firstArg = Console.ReadLine(); } IClientVisitor client; switch (firstArg) { case "gg": client = new WebSocketClient(PrivateConstants.BotWebsocketAuth); break; case "ggl": client = new WebSocketListenerClient(PrivateConstants.BotWebsocketAuth); break; case "t": client = new SimpleIrcClient(server, port, channel, nick, pass); break; case "tl": client = new SimpleIrcListenerClient(server, port, channel, nick, pass); break; case "s": client = new SampleClient(); break; default: throw new Exception("Invalid input"); } new PrimaryLogic(client).Run(); }
public async Task Send_Start_ReceiveDataOnMutation_Large_Message() { using (TestServer testServer = CreateStarWarsServer()) { // arrange WebSocketClient client = CreateWebSocketClient(testServer); WebSocket webSocket = await ConnectToServerAsync(client); var document = Utf8GraphQLParser.Parse( "subscription { onReview(episode: NEWHOPE) { stars } }"); var request = new GraphQLRequest(document); const string subscriptionId = "abc"; // act await webSocket.SendSubscriptionStartAsync( subscriptionId, request, true); // assert await webSocket.SendEmptyMessageAsync(); await testServer.SendRequestAsync(new ClientQueryRequest { Query = @" mutation { createReview(episode:NEWHOPE review: { commentary: ""foo"" stars: 5 }) { stars } } " }); IReadOnlyDictionary <string, object> message = await WaitForMessage( webSocket, MessageTypes.Subscription.Data, TimeSpan.FromSeconds(15)); Assert.NotNull(message); message.MatchSnapshot(); } }
private void ConfigureLogic() { var messages = new List <string>(); var listViewAdapter = new ArrayAdapter(this, Android.Resource.Layout.SimpleExpandableListItem1, messages); listView.Adapter = listViewAdapter; Action <string> sendMessageCallback = (message) => { RunOnUiThread(() => { listViewAdapter.Add(message); listViewAdapter.NotifyDataSetChanged(); }); }; WebSocketClient.AddCallBack(ServerMethod.SendMessage, sendMessageCallback); }
internal static async Task <Operation> ModifyOperation(WebSocketClient client, Operation modifiedOperation) { Operation dbOperation; bool newOp = false; using (var ctx = new ScavengePadDbContext()) { dbOperation = await ctx.Operations .Where(c => c.Id == modifiedOperation.Id) .Where(c => c.TeamId == client.User.TeamId) .AsNoTracking() .FirstOrDefaultAsync(); if (dbOperation == null) { dbOperation = new Operation() { TeamId = client.User.TeamId, Title = modifiedOperation.Title, Objectives = modifiedOperation.Objectives }; ctx.Operations.Add(dbOperation); newOp = true; } else { ctx.Operations.Update(modifiedOperation); dbOperation = modifiedOperation; } await ctx.SaveChangesAsync(); if (newOp) { dbOperation.OperationPadSuffix = WebUtility.UrlEncode(ScavengePadUtils.SHA256($"{dbOperation.Id}{ScavengePadUtils.GetRandomInt()}{ScavengePadUtils.GetRandomInt()}{ScavengePadUtils.GetRandomInt()}{ScavengePadUtils.GetRandomInt()}")); } foreach (var objective in dbOperation.Objectives) { if (objective.ObjectivePadSuffix == "default") { objective.ObjectivePadSuffix = WebUtility.UrlEncode(ScavengePadUtils.SHA256($"{objective.Id}{ScavengePadUtils.GetRandomInt()}{ScavengePadUtils.GetRandomInt()}{ScavengePadUtils.GetRandomInt()}{ScavengePadUtils.GetRandomInt()}")); } } await ctx.SaveChangesAsync(); } return(await GetOperation(dbOperation.Id)); }
public async Task <bool> Connect(Uri peerUri) { try { ConnectionLogger?.Invoke($"Establishing connection: {peerUri.OriginalString}"); await WebSocketClient.Connect(peerUri, ConnectionLogger); return(await Task.FromResult(true)); } catch (WebSocketException e) { Debug.WriteLine($"Caught web socket exception {e.Message}"); ConnectionLogger?.Invoke(e.Message); return(await Task.FromResult(false)); } }
public async Task <bool> OpenRepository(string connectionUri) { try { WebSocketConnection = await WebSocketClient.ConnectAsync(new Uri(connectionUri)); WebSocketConnection.OnMessage += (e, a) => OnMessage(a.Message); WebSocketConnection.OnError += (e, a) => OnError(a.Exception); WebSocketConnection.OnClose += WebSocketConnection_OnClose; return(true); } catch (Exception e) { Debug.WriteLine(e); return(false); } }
public static void BotConnect() { try { // Checks if twitch credentials are present if (string.IsNullOrEmpty(Settings.Settings.TwAcc) || string.IsNullOrEmpty(Settings.Settings.TwOAuth) || string.IsNullOrEmpty(Settings.Settings.TwChannel)) { Application.Current.Dispatcher.Invoke(() => { foreach (Window window in Application.Current.Windows) { if (window.GetType() == typeof(MainWindow)) { //(window as MainWindow).icon_Twitch.Foreground = new SolidColorBrush(Colors.Red); ((MainWindow)window).LblStatus.Content = "Please fill in Twitch credentials."; } } }); return; } // creates new connection based on the credentials in settings ConnectionCredentials credentials = new ConnectionCredentials(Settings.Settings.TwAcc, Settings.Settings.TwOAuth); ClientOptions clientOptions = new ClientOptions { MessagesAllowedInPeriod = 750, ThrottlingPeriod = TimeSpan.FromSeconds(30) }; WebSocketClient customClient = new WebSocketClient(clientOptions); Client = new TwitchClient(customClient); Client.Initialize(credentials, Settings.Settings.TwChannel); Client.OnMessageReceived += _client_OnMessageReceived; Client.OnConnected += _client_OnConnected; Client.OnDisconnected += _client_OnDisconnected; Client.Connect(); // subscirbes to the cooldowntimer elapsed event for the command cooldown CooldownTimer.Elapsed += CooldownTimer_Elapsed; } catch (Exception) { Logger.LogStr("Couldn't connect to Twitch, mabe credentials are wrong?"); } }
private void twitch_connect() { ConnectionCredentials credentials = new ConnectionCredentials(TwitchBotName, TwitchBotOauth); var clientOptions = new ClientOptions { MessagesAllowedInPeriod = 100, ThrottlingPeriod = TimeSpan.FromSeconds(60) }; var customClient = new WebSocketClient(clientOptions); var client = new TwitchClient(customClient); client.Initialize(credentials, TwitchBotChannel); client.OnGiftedSubscription += giftsub; client.OnNewSubscriber += newsub; client.OnReSubscriber += resub; client.Connect(); }
static void Main(string[] args) { ManualResetEventSlim mr = new ManualResetEventSlim(); var client = new WebSocketClient(new Uri("ws://localhost:81/")); ObservableSoundCapture capture = new ObservableSoundCapture(); ObservableSpeexEncoder encoder = new ObservableSpeexEncoder(6400); capture.Subscribe(encoder); var encoderSender = encoder.Select(x => new SenderModel("TestChannel", true, x)); capture.Start(); encoderSender.Subscribe(client); client.Start(); mr.Wait(); }
public GdsWebSocketClient(String uri, String userName, string certPath, string pw) { FileStream f = File.OpenRead(certPath); byte[] data = new byte[f.Length]; f.Read(data, 0, data.Length); f.Close(); this.client = new WebSocketClient(uri, data, pw); this.userName = userName; this.password = null; client.MessageReceived += Client_MessageReceived; client.Disconnected += Client_Disconnected; this.uri = uri; }
public async Task SendLongData_Success() { using (HttpListener listener = new HttpListener()) { listener.Prefixes.Add(ServerAddress); listener.Start(); Task <HttpListenerContext> serverAccept = listener.GetContextAsync(); WebSocketClient client = new WebSocketClient(); Task <WebSocket> clientConnect = client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None); HttpListenerContext serverContext = await serverAccept; Assert.True(serverContext.Request.IsWebSocketRequest); HttpListenerWebSocketContext serverWebSocketContext = await serverContext.AcceptWebSocketAsync(null, 0xFFFF, TimeSpan.FromMinutes(100)); WebSocket clientSocket = await clientConnect; byte[] orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); await clientSocket.SendAsync(new ArraySegment <byte>(orriginalData), WebSocketMessageType.Text, true, CancellationToken.None); byte[] serverBuffer = new byte[orriginalData.Length]; WebSocketReceiveResult result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer), CancellationToken.None); int intermediateCount = result.Count; Assert.False(result.EndOfMessage); Assert.Equal(WebSocketMessageType.Text, result.MessageType); result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None); intermediateCount += result.Count; Assert.False(result.EndOfMessage); Assert.Equal(WebSocketMessageType.Text, result.MessageType); result = await serverWebSocketContext.WebSocket.ReceiveAsync(new ArraySegment <byte>(serverBuffer, intermediateCount, orriginalData.Length - intermediateCount), CancellationToken.None); intermediateCount += result.Count; Assert.True(result.EndOfMessage); Assert.Equal(orriginalData.Length, intermediateCount); Assert.Equal(WebSocketMessageType.Text, result.MessageType); Assert.Equal(orriginalData, serverBuffer); clientSocket.Dispose(); } }
/// <exception cref="InvalidOperationException">The client must be logged in before connecting.</exception> /// <exception cref="NotSupportedException">This client is not configured with WebSocket support.</exception> internal override async Task ConnectInternalAsync() { if (LoginState != LoginState.LoggedIn) throw new InvalidOperationException("The client must be logged in before connecting."); if (WebSocketClient == null) throw new NotSupportedException("This client is not configured with WebSocket support."); RequestQueue.ClearGatewayBuckets(); //Re-create streams to reset the zlib state _compressed?.Dispose(); _decompressor?.Dispose(); _compressed = new MemoryStream(); _decompressor = new DeflateStream(_compressed, CompressionMode.Decompress); ConnectionState = ConnectionState.Connecting; try { _connectCancelToken?.Dispose(); _connectCancelToken = new CancellationTokenSource(); if (WebSocketClient != null) WebSocketClient.SetCancelToken(_connectCancelToken.Token); if (!_isExplicitUrl) { var gatewayResponse = await GetGatewayAsync().ConfigureAwait(false); _gatewayUrl = $"{gatewayResponse.Url}?v={DiscordConfig.APIVersion}&encoding={DiscordSocketConfig.GatewayEncoding}&compress=zlib-stream"; } #if DEBUG_PACKETS Console.WriteLine("Connecting to gateway: " + _gatewayUrl); #endif await WebSocketClient.ConnectAsync(_gatewayUrl).ConfigureAwait(false); ConnectionState = ConnectionState.Connected; } catch { if (!_isExplicitUrl) _gatewayUrl = null; //Uncache in case the gateway url changed await DisconnectInternalAsync().ConfigureAwait(false); throw; } }
public async Task ReceiveFragmentedData_Success() { var orriginalData = Encoding.UTF8.GetBytes("Hello World"); using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); var webSocket = await context.WebSockets.AcceptWebSocketAsync(); await webSocket.SendAsync(new ArraySegment <byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); await webSocket.SendAsync(new ArraySegment <byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None); await webSocket.SendAsync(new ArraySegment <byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None); })) { var client = new WebSocketClient(); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { var clientBuffer = new byte[orriginalData.Length]; var result = await clientSocket.ReceiveAsync(new ArraySegment <byte>(clientBuffer), CancellationToken.None); Assert.False(result.EndOfMessage); Assert.Equal(2, result.Count); int totalReceived = result.Count; Assert.Equal(WebSocketMessageType.Binary, result.MessageType); result = await clientSocket.ReceiveAsync( new ArraySegment <byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); Assert.False(result.EndOfMessage); Assert.Equal(2, result.Count); totalReceived += result.Count; Assert.Equal(WebSocketMessageType.Binary, result.MessageType); result = await clientSocket.ReceiveAsync( new ArraySegment <byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); Assert.True(result.EndOfMessage); Assert.Equal(7, result.Count); totalReceived += result.Count; Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(orriginalData, clientBuffer); } } }
public Bot(string channel, string token, string Username, List <command> commandList, List <sfx> sfxList, LiteDB.ILiteCollection <counter> countersCol, LiteDB.ILiteCollection <swearJarAcc> accountsColl, List <string> ctList, bool requireModBool, bool quoteBool, bool isPrettyBool, bool coinBool, bool diceBool, int pretyInt, bool sjBool, float sjDenom, bool dadJ) { countersList = ctList; counters = countersCol; commands = commandList; sfxes = sfxList; quote = quoteBool; requireMod = requireModBool; pretty = isPrettyBool; dice = diceBool; coin = coinBool; swearJar = sjBool; pretyIntVal = pretyInt; accounts = accountsColl; dadBool = dadJ; denomination = sjDenom; if (Username == "") { Username = "******"; } if (token == "") { token = "oauth:x64c6vsc9pfxnajwp16slxhusuiy9e"; } ConnectionCredentials credentials = new ConnectionCredentials(Username, token); WebSocketClient customClient = new WebSocketClient(); client = new TwitchClient(customClient); client.Initialize(credentials, channel); client.OnLog += Client_OnLog; client.OnJoinedChannel += Client_OnJoinedChannel; client.OnMessageReceived += Client_OnMessageReceived; //client.OnWhisperReceived += Client_OnWhisperReceived; //client.OnNewSubscriber += Client_OnNewSubscriber; client.OnConnected += Client_OnConnected; client.OnDisconnected += Client_OnDisconnected; client.OnConnectionError += onConnectionError; client.Connect(); }
async void OnLogin_Clicked(object sender, EventArgs args) { loadingDialog = UserDialogs.Instance.Loading("Connecting...",null,null,false,MaskType.Gradient); if (String.IsNullOrEmpty(webSocketUrl.Text)) { await DisplayAlert("Validation Error", "Server URL is required", "Re-try"); } else { //if(false){ if (String.IsNullOrEmpty (username.Text) || String.IsNullOrEmpty (password.Text)) { await DisplayAlert ("Validation Error", "Username and Password are required", "Re-try"); } else { await App.Database.Delete_RemoteData_Item (); await App.Database.Delete_All_Login_Username_Show_For_Del (); loadingDialog.Show (); //System.Threading.Tasks.Task.Run (() => //{ ws_client = new WebSocketClient (); ws_client.Opened += websocket_Opened; ws_client.Closed += websocket_Closed; ws_client.MessageReceived += websocket_MessageReceived; //ws_client.AutoSendPongResponse = true; //}); try { Debug.WriteLine ("Websocket Opening....."); await ws_client.OpenAsync(webSocketUrl.Text); } catch (Exception ex) { Debug.WriteLine (ex.ToString()); Debug.WriteLine ("OpenAsync Exception"); UserDialogs.Instance.ShowError ("Can not Connect to Websocket Server"); } } } }
public Task Send_Start_ReceiveDataOnMutation() { SnapshotFullName snapshotName = Snapshot.FullName(); return(TryTest(async() => { // arrange using TestServer testServer = CreateStarWarsServer(); WebSocketClient client = CreateWebSocketClient(testServer); WebSocket webSocket = await ConnectToServerAsync(client); DocumentNode document = Utf8GraphQLParser.Parse( "subscription { onReview(episode: NEW_HOPE) { stars } }"); var request = new GraphQLRequest(document); const string subscriptionId = "abc"; // act await webSocket.SendSubscriptionStartAsync(subscriptionId, request); // assert await testServer.SendPostRequestAsync(new ClientQueryRequest { Query = @" mutation { createReview(episode: NEW_HOPE review: { commentary: ""foo"" stars: 5 }) { stars } }" }); IReadOnlyDictionary <string, object> message = await WaitForMessage( webSocket, MessageTypes.Subscription.Data, TimeSpan.FromSeconds(15)); Assert.NotNull(message); Snapshot.Match(message, snapshotName); })); }
public async Task InvokeAsync(HttpContext context) { //验证请求地址 if (TenantPathCache.Match(context.Request.Path)) { //验证是否为websocket请求 if (context.WebSockets.IsWebSocketRequest) { //获取当前租户的配置信息 var webSocketOption = await socketOptionFactory.GetAsync(context.Request.Path); //获取buff接收大小 ReciveBuffSize = webSocketOption.MaximumReceiveMessageSize; //授权验证 foreach (var item in webSocketOption.AuthorizationFilters) { if ((await item.AuthorizationAsync(context)) == false) { context.Response.StatusCode = (int)HttpStatusCode.Unauthorized; return; } } //获取传递的连接Id var connectionId = context.Request.Query[RequestQuery.ConnectionId.ToString()]; //接收websocket客户端 var webSocketClient = new WebSocketClient { WebSocket = await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false), ConnectionId = connectionId.Any() ? connectionId.ToString() : Guid.NewGuid().ToString(), Context = context }; //处理 await Handler(context, webSocketClient).ConfigureAwait(false); } else { context.Response.StatusCode = (int)HttpStatusCode.NotFound; logger.LogWarning("当前不是一个有效的webscoket连接"); } } else { await next(context); } }
/// <exception cref="NotSupportedException">This client is not configured with WebSocket support.</exception> internal override async Task DisconnectInternalAsync(Exception ex = null) { if (WebSocketClient == null) throw new NotSupportedException("This client is not configured with WebSocket support."); if (ConnectionState == ConnectionState.Disconnected) return; ConnectionState = ConnectionState.Disconnecting; try { _connectCancelToken?.Cancel(false); } catch { } if (ex is GatewayReconnectException) await WebSocketClient.DisconnectAsync(4000).ConfigureAwait(false); else await WebSocketClient.DisconnectAsync().ConfigureAwait(false); ConnectionState = ConnectionState.Disconnected; }
///<summary> /// Class Constructor that handles the Gazetracker client and the WebSocket connections. /// </summary> public WSClient() { createXml(); wsClient = new WebSocketClient("ws://ciman.math.unipd.it:8000/") { OnConnected = OnConnected, OnDisconnect = OnDisconnect, OnFailedConnection = OnFailedConnection, OnReceive = OnReceive }; gtClient = new GazeTrackerClient.Client(); gtClient.ErrorOccured += OnErrorOccured; gtClient.Calibration.OnPointChange += new GazeTrackerClient.Calibration.PointChangeHandler(OnCalibrationPointChange); gtClient.Calibration.OnEnd += new GazeTrackerClient.Calibration.EndHandler(OnCalibrationEnd); gtClient.GazeData.OnGazeData += new GazeTrackerClient.GazeData.GazeDataHandler(OnGazeData); }
static void Main() { var client = new WebSocketClient(); client.MessageReceived += m => { if (m.IsText) Console.WriteLine("RESPONSE: {0}", m.ToString()); }; client.OpenAsync("wss://echo.websocket.org").Wait(); Console.WriteLine("Client connected, enter text and send it with pressing <ENTER>"); var text = Console.ReadLine(); while (!string.IsNullOrEmpty(text)) { client.SendAsync(text); text = Console.ReadLine(); } }
public async Task WebSocketClient_AcceptsAnyUrl() { Exception result = null; WebSocketClient reader = null; try { var webSocketClient = new WebSocketClient("fakeurl"); reader = webSocketClient; } catch (Exception ex) { result = ex; } reader.Dispose(); Assert.Null(result); }
public void StressTest1() { var waitEvent = new AutoResetEvent(false); var server = new WebSocketServer(8080); server.OnReceive += Receive; server.Start(); WebSocketClient socket = new WebSocketClient("ws://localhost:8080/"); socket.Connect(); countdownEvent = new CountdownEvent(Messages); for (var i = 0; i < Messages; i++) ThreadPool.QueueUserWorkItem(DoSend, socket); countdownEvent.Wait(new TimeSpan(0, 0, 120)); Assert.AreEqual(0, countdownEvent.CurrentCount); }
public void Execute(WebSocketClient SocketClient, MessageObject Data) { var message = Convert.ToString(Data.Body["message"]); if (message.Contains('<') || message.Contains('>')) { SocketClient.Send(new ErrorHandler("Chat message can't contain special characters")); return; } if (!SocketClient.Game.HasStarted) { SocketClient.Send(new ErrorHandler("Game hasn't started")); return; } SocketClient.Game.SendToPlayers(new ReceiveMessageHandler(SocketClient.Nickname, message, DateTime.Now.ToString("HH:mm:ss"))); }
public async Task HeartbeatLoop(int inter) { while (_heartbeat) { await Task.Delay(inter).ConfigureAwait(false); if (WebSocketClient.State == WebSocketState.Open) { PingStopwatch.Reset(); PingStopwatch.Start(); WebSocketClient.Send(@"{""op"":1, ""t"":null,""d"":null,""s"":null}"); } else { break; } } }
public M2Bot(IOptions <TwitchConfig> twitchOptions, IEnumerable <IChatCommand> chatCommands, ILogger <M2Bot> logger) { _twitchConfig = twitchOptions.Value; _chatCommands = chatCommands; _logger = logger; var twitchClientOptions = new ClientOptions { MessagesAllowedInPeriod = 750, ThrottlingPeriod = TimeSpan.FromSeconds(30) }; var socketClient = new WebSocketClient(twitchClientOptions); _client = new TwitchClient(socketClient); }
private void SetupWebSocketConnection(string botId, string botPassword) { if (!_useWebSockets) { return; } Connector.Authentication.MicrosoftAppCredentials appCredentials = new Connector.Authentication.MicrosoftAppCredentials(botId, botPassword); var authHeaders = new Dictionary <string, string>() { { "authorization", $"Bearer {appCredentials.GetTokenAsync().Result}" }, { "channelid", "emulator" } }; // Bots hosted on Azure will require the authHeaders be passed in as the third argument below. For local testing they are optional and may cause undesired behavior. // Setting the channelId to emulator causes the BotFrameworkAdapter in the target bot to treat activities differently. Search for the string 'emulator' in // the BotBuilder repo to learn more. _webSocketClient = new WebSocketClient(this._TargetBotEndPoint, _handler, null); _webSocketClient.ConnectAsync(authHeaders).Wait(); }
public TwitchChatBot( IOptionsMonitor <TwitchSettings> optionsMonitor, ILogger <TwitchChatBot> logger ) { _logger = logger; var credentials = new ConnectionCredentials("raw_coding", optionsMonitor.CurrentValue.AccessToken); var clientOptions = new ClientOptions { MessagesAllowedInPeriod = 750, ThrottlingPeriod = TimeSpan.FromSeconds(30) }; var customClient = new WebSocketClient(clientOptions); _client = new(customClient); _client.Initialize(credentials, "raw_coding"); _client.OnLog += Client_OnLog; }
private async Task DisconnectInternalAsync() { if (ConnectionState == ConnectionState.Disconnected) { return; } ConnectionState = ConnectionState.Disconnecting; try { _connectCancelToken?.Cancel(false); } catch { } //Wait for tasks to complete await _udp.StopAsync().ConfigureAwait(false); await WebSocketClient.DisconnectAsync().ConfigureAwait(false); ConnectionState = ConnectionState.Disconnected; }
/// <summary> /// Constructor for a client that interface's with Twitch's PubSub system. /// </summary> /// <param name="logger">Optional ILogger param to enable logging</param> public TwitchPubSub(ILogger <TwitchPubSub> logger = null) { _logger = logger; var options = new ClientOptions { ClientType = ClientType.PubSub }; _socket = new WebSocketClient(options); _socket.OnConnected += Socket_OnConnected; _socket.OnError += OnError; _socket.OnMessage += OnMessage; _socket.OnDisconnected += Socket_OnDisconnected; _pongTimer.Interval = 15000; //15 seconds, we should get a pong back within 10 seconds. _pongTimer.Elapsed += PongTimerTick; }
public void BeginListenTrades(ICollection <ISymbol> symbols) { var pairs = new List <string>(); foreach (var symbol in symbols) { var baseCurrency = Exchange.GetCurrencyCode(symbol.BaseCurrencyCode); var quoteCurrency = Exchange.GetCurrencyCode(symbol.QuoteCurrencyCode); pairs.Add($"{baseCurrency}/{quoteCurrency}"); } WebSocketClient.Send(JsonConvert.SerializeObject(new SubscriptionRequest { Event = "subscribe", Pair = pairs, Subscription = new BaseEventInnerRequest { Name = "trade" } })); }
public Bot() { ConnectionCredentials creds = new ConnectionCredentials(Info.BotUsername, Info.BotToken); var clientOptions = new ClientOptions { MessagesAllowedInPeriod = 750, ThrottlingPeriod = TimeSpan.FromSeconds(30) }; WebSocketClient customClient = new WebSocketClient(clientOptions); client = new TwitchClient(customClient); client.Initialize(creds, Info.ChannelName); client.OnJoinedChannel += Client_OnJoinedChannel; client.OnMessageReceived += Client_OnMessageReceived; client.Connect(); }
public async Task NegotiateSubProtocol_Success() { using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); Assert.Equal("alpha, bravo, charlie", context.Request.Headers["Sec-WebSocket-Protocol"]); var webSocket = await context.WebSockets.AcceptWebSocketAsync("Bravo"); })) { var client = new WebSocketClient(); client.SubProtocols.Add("alpha"); client.SubProtocols.Add("bravo"); client.SubProtocols.Add("charlie"); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { Assert.Equal("Bravo", clientSocket.SubProtocol); } } }
public async Task SendEmptyData_Success() { using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); var webSocket = await context.WebSockets.AcceptWebSocketAsync(); var serverBuffer = new byte[0]; var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); Assert.True(result.EndOfMessage); Assert.Equal(0, result.Count); Assert.Equal(WebSocketMessageType.Binary, result.MessageType); })) { var client = new WebSocketClient(); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { var orriginalData = new byte[0]; await clientSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); } } }
private void CreateClient(Socket client) { WebSocketClient wsc = null; //証明書がセットされていたら、 //暗号化モードでクライアントを初期化する。 if(cert == null) { wsc = new WebSocketClient(client); }else{ wsc = new WebSocketClient(client,cert); } wsc.Handshake(); Task.Run(()=> {wsc.Run();}); //接続時のイベント起動 var e = new ClientConnectedEventArgs(); e.Client = wsc; OnClientConnectedHandler(e); }
public async Task TestWebsocketPortable() { counter = 0; var client = new WebSocketClient(); client.Opened += websocket_Opened; client.Closed += websocket_Closed; client.MessageReceived += websocket_MessageReceived; //Never Ending await client.OpenAsync("ws://echo.websocket.org"); await client.SendAsync("Hello World"); await client.SendAsync("Hello World2"); await Task.Delay(500); Assert.IsTrue(counter == 2); Debug.WriteLine("TestWebsocketPortable"); }
private int receiveWebsocket(byte[] data, uint len, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES e) { string sdata = Encoding.ASCII.GetString(data, 0, (int)len); try { WSData msg = JsonConvert.DeserializeObject<WSData>(sdata); if (msg.type != "nop") debug("websocket receive: " + sdata); if (msg.type == "tickle" && msg.subtype == "push") checkPushes(); } catch (Exception) { debug("unknown websocket data received"); } wsCli.ReceiveAsync(); return 0; }
private void openWebsocket() { // wss://stream.pushbullet.com/websocket/<your_access_token_here> try { wsCli = new WebSocketClient(); wsCli.SSL = true; wsCli.Port = WebSocketClient.WEBSOCKET_DEF_SSL_SECURE_PORT; wsCli.URL = "wss://stream.pushbullet.com/websocket/" + apiToken; wsCli.ConnectionCallBack = connectWebsocket; wsCli.ReceiveCallBack = receiveWebsocket; wsCli.ConnectAsync(); } catch (Exception e) { debug("Failed to set up websocket: " + e.Message); } }
private int connectWebsocket(WebSocketClient.WEBSOCKET_RESULT_CODES err) { debug("websocket error = " + err); if (err == WebSocketClient.WEBSOCKET_RESULT_CODES.WEBSOCKET_CLIENT_SUCCESS) { online = true; debug("Connected"); wsCli.ReceiveAsync(); } else { online = false; debug("WebSocket offline"); } return 0; }
public WebSocketMessageHandler(ConnectionMaintainer cm) { this._connectionMaintainer = cm; WebSocketClient = new WebSocketClient(this); WebSocketServer = new WebSocketServer(this); }
public async Task ReceiveFragmentedData_Success() { var orriginalData = Encoding.UTF8.GetBytes("Hello World"); using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); var webSocket = await context.WebSockets.AcceptWebSocketAsync(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None); })) { var client = new WebSocketClient(); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { var clientBuffer = new byte[orriginalData.Length]; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); Assert.False(result.EndOfMessage); Assert.Equal(2, result.Count); int totalReceived = result.Count; Assert.Equal(WebSocketMessageType.Binary, result.MessageType); result = await clientSocket.ReceiveAsync( new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); Assert.False(result.EndOfMessage); Assert.Equal(2, result.Count); totalReceived += result.Count; Assert.Equal(WebSocketMessageType.Binary, result.MessageType); result = await clientSocket.ReceiveAsync( new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); Assert.True(result.EndOfMessage); Assert.Equal(7, result.Count); totalReceived += result.Count; Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(orriginalData, clientBuffer); } } }
public void SendAndRecieve() { WebSocketClient ws = new WebSocketClient(new Uri("ws://localhost:8080/YASO/chat")); ManualResetEvent receiveEvent = new ManualResetEvent(false); ws.OnMessage += (s, e) => { receiveEvent.Set(); }; ws.Connect(); ws.Send("login: "******"Msg #" + i); received = receiveEvent.WaitOne(TimeSpan.FromSeconds(2)); Assert.IsTrue(received, "Fail on round " + i); } receiveEvent.Close(); ws.Close(); }
public void Send() { WebSocketClient ws = new WebSocketClient(new Uri("ws://localhost:8080/YASO/chat")); ws.Connect(); ws.Send("login: User1"); ws.Close(); }
/// <summary> /// The Following Three Methods are for the Websocket /// </summary> /// <param name="error"></param> /// <returns></returns> public static int SendCallback(WebSocketClient.WEBSOCKET_RESULT_CODES error) { try { ret = wsc.ReceiveAsync(); } catch (Exception e) { return -1; } return 0; }
public async Task CloseFromCloseReceived_Success() { string closeDescription = "Test Closed"; using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); var webSocket = await context.WebSockets.AcceptWebSocketAsync(); await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); var serverBuffer = new byte[1024]; var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); Assert.True(result.EndOfMessage); Assert.Equal(0, result.Count); Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); Assert.Equal(closeDescription, result.CloseStatusDescription); })) { var client = new WebSocketClient(); using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { var clientBuffer = new byte[1024]; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); Assert.True(result.EndOfMessage); Assert.Equal(0, result.Count); Assert.Equal(WebSocketMessageType.Close, result.MessageType); Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); Assert.Equal(closeDescription, result.CloseStatusDescription); Assert.Equal(WebSocketState.CloseReceived, clientSocket.State); await clientSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); Assert.Equal(WebSocketState.Closed, clientSocket.State); } } }
static void Main(string[] args) { try { var config = new WebSocketClientConfiguration(); //config.SslTargetHost = "Cowboy"; //config.SslClientCertificates.Add(new System.Security.Cryptography.X509Certificates.X509Certificate2(@"D:\\Cowboy.cer")); //config.SslPolicyErrorsBypassed = true; var uri = new Uri("ws://echo.websocket.org/"); //var uri = new Uri("wss://127.0.0.1:22222/test"); //var uri = new Uri("ws://127.0.0.1:22222/test"); _client = new WebSocketClient(uri, config, _log); _client.ServerConnected += OnServerConnected; _client.ServerDisconnected += OnServerDisconnected; _client.ServerTextReceived += OnServerTextReceived; _client.ServerBinaryReceived += OnServerBinaryReceived; _client.Connect(); Console.WriteLine("WebSocket client has connected to server [{0}].", uri); Console.WriteLine("Type something to send to server..."); while (_client.State == WebSocketState.Open) { try { string text = Console.ReadLine(); if (text == "quit") break; if (text == "many") { text = new string('x', 1024); Stopwatch watch = Stopwatch.StartNew(); int count = 10000; for (int i = 1; i <= count; i++) { _client.SendBinary(Encoding.UTF8.GetBytes(text)); Console.WriteLine("Client [{0}] send binary -> Sequence[{1}] -> TextLength[{2}].", _client.LocalEndPoint, i, text.Length); } watch.Stop(); Console.WriteLine("Client [{0}] send binary -> Count[{1}] -> Cost[{2}] -> PerSecond[{3}].", _client.LocalEndPoint, count, watch.ElapsedMilliseconds / 1000, count / (watch.ElapsedMilliseconds / 1000)); } else if (text == "big") { text = new string('x', 1024 * 1024 * 100); _client.SendBinary(Encoding.UTF8.GetBytes(text)); Console.WriteLine("Client [{0}] send binary -> [{1}].", _client.LocalEndPoint, text); } else { _client.SendBinary(Encoding.UTF8.GetBytes(text)); Console.WriteLine("Client [{0}] send binary -> [{1}].", _client.LocalEndPoint, text); //_client.SendText(text); //Console.WriteLine("Client [{0}] send text -> [{1}].", _client.LocalEndPoint, text); } } catch (Exception ex) { Console.WriteLine(ex.Message); } } _client.Close(WebSocketCloseCode.NormalClosure); Console.WriteLine("WebSocket client has disconnected from server [{0}].", uri); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); }
public static int ReceiveCallback(byte[] data, uint datalen, WebSocketClient.WEBSOCKET_PACKET_TYPES opcode, WebSocketClient.WEBSOCKET_RESULT_CODES error) { try { string s = Encoding.UTF8.GetString(data, 0, data.Length); if (s.Contains("push")) { getPush(); } } catch (Exception e) { return -1; } return 0; }
public async Task ReceiveLongDataInLargeBuffer_Success() { var orriginalData = Encoding.UTF8.GetBytes(new string('a', 0x1FFFF)); using (var server = KestrelWebSocketHelpers.CreateServer(async context => { Assert.True(context.WebSockets.IsWebSocketRequest); var webSocket = await context.WebSockets.AcceptWebSocketAsync(); await webSocket.SendAsync(new ArraySegment<byte>(orriginalData), WebSocketMessageType.Binary, true, CancellationToken.None); })) { var client = new WebSocketClient() { ReceiveBufferSize = 0xFFFFFF }; using (var clientSocket = await client.ConnectAsync(new Uri(ClientAddress), CancellationToken.None)) { var clientBuffer = new byte[orriginalData.Length]; var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); Assert.True(result.EndOfMessage); Assert.Equal(orriginalData.Length, result.Count); Assert.Equal(WebSocketMessageType.Binary, result.MessageType); Assert.Equal(orriginalData, clientBuffer); } } }
public void Connect() { WebSocketClient ws = new WebSocketClient(new Uri("ws://localhost:8080/YASO/chat")); ws.Connect(); ws.Close(); }
private void DoAcceptTcpClient(IAsyncResult ar) { var callback = ar.AsyncState as MensagemRecebidaCallback; bool startAcceptPending = false; Interlocked.Increment(ref clientCount); if (clientCount < CLIENT_LIMIT) StartAccept(callback); else startAcceptPending = true; using (var client = new WebSocketClient(listener.EndAcceptTcpClient(ar), callback)) { }; Interlocked.Decrement(ref clientCount); if(startAcceptPending) StartAccept(callback); }
private async Task TestBigString() { var client = new WebSocketClient(); client.Opened += websocket_Opened; client.Closed += websocket_Closed; client.MessageReceived += websocket_MessageReceived; client.Error += Client_Error; //Never Ending await client.OpenAsync("ws://echo.websocket.org"); var sb = new StringBuilder(); for (int i = 0;i < 1000;i++) { sb.Append("A"); } for (int i = 0; i < 5; i++) { await client.SendAsync(sb.ToString()); } await Task.Delay(1000); await client.CloseAsync(); await Task.Delay(100); Debug.WriteLine("TestWebsocketPortable"); }