/// <summary> Creates a new REST-only Discord client. </summary> internal BaseDiscordClient(DiscordRestConfig config, API.DiscordRestApiClient client) { ApiClient = client; LogManager = new LogManager(config.LogLevel); LogManager.Message += async msg => await _logEvent.InvokeAsync(msg).ConfigureAwait(false); _stateLock = new SemaphoreSlim(1, 1); _restLogger = LogManager.CreateLogger("Rest"); _isFirstLogin = config.DisplayInitialLog; UseInteractionSnowflakeDate = config.UseInteractionSnowflakeDate; ApiClient.RequestQueue.RateLimitTriggered += async(id, info, endpoint) => { if (info == null) { await _restLogger.VerboseAsync($"Preemptive Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}").ConfigureAwait(false); } else { await _restLogger.WarningAsync($"Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}").ConfigureAwait(false); } }; ApiClient.SentRequest += async(method, endpoint, millis) => await _restLogger.VerboseAsync($"{method} {endpoint}: {millis} ms").ConfigureAwait(false); }
private async Task LoginInternalAsync(TokenType tokenType, string token) { if (_isFirstLogin) { _isFirstLogin = false; await LogManager.WriteInitialLog().ConfigureAwait(false); } if (LoginState != LoginState.LoggedOut) { await LogoutInternalAsync().ConfigureAwait(false); } LoginState = LoginState.LoggingIn; try { await ApiClient.LoginAsync(tokenType, token).ConfigureAwait(false); await OnLoginAsync(tokenType, token).ConfigureAwait(false); LoginState = LoginState.LoggedIn; } catch (Exception) { await LogoutInternalAsync().ConfigureAwait(false); throw; } await _loggedInEvent.InvokeAsync().ConfigureAwait(false); }
private async Task <TResponse> SendRpcAsyncInternal <TResponse>(string cmd, object payload, Optional <string> evt, RequestOptions options) where TResponse : class { byte[] bytes = null; var guid = Guid.NewGuid(); payload = new API.Rpc.RpcFrame { Cmd = cmd, Event = evt, Args = payload, Nonce = guid }; if (payload != null) { var json = SerializeJson(payload); bytes = Encoding.UTF8.GetBytes(json); } var requestTracker = new RpcRequest <TResponse>(options); _requests[guid] = requestTracker; await RequestQueue.SendAsync(new WebSocketRequest(_webSocketClient, null, bytes, true, options)).ConfigureAwait(false); await _sentRpcMessageEvent.InvokeAsync(cmd).ConfigureAwait(false); return(await requestTracker.Promise.Task.ConfigureAwait(false)); }
internal async Task CallOnMessageAsync(string result) { await _on_message.InvokeAsync(new SocketMessageEventArgs() { Message = result }); }
public TwitchPubsubApiClient(RestClientProvider restClientProvider, SocketClientProvider socketClientProvider, string clientId, string userAgent, string webSocketUrl, RetryMode defaultRetryMode = RetryMode.AlwaysRetry, JsonSerializer serializer = null) : base(restClientProvider, clientId, userAgent, serializer) { _webSocketUrl = webSocketUrl; WebSocketClient = socketClientProvider() as IWebSocketClient; _callbacks = new ConcurrentDictionary <string, Func <PubsubFrame <string>, Task> >(); WebSocketClient.TextMessage += async text => { using (var reader = new StringReader(text)) using (var jsonReader = new JsonTextReader(reader)) { var msg = _serializer.Deserialize <PubsubFrame <string> >(jsonReader); if (msg != null) { await _receivedPubsubEvent.InvokeAsync(msg).ConfigureAwait(false); } } }; WebSocketClient.Closed += async ex => { await DisconnectAsync().ConfigureAwait(false); await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false); }; }
private async Task DisconnectInternalAsync(Exception ex) { if (ConnectionState == ConnectionState.Disconnected) { return; } ConnectionState = ConnectionState.Disconnecting; await _audioLogger.InfoAsync("Disconnecting").ConfigureAwait(false); //Signal tasks to complete try { _cancelToken.Cancel(); } catch { } //Disconnect from server await ApiClient.DisconnectAsync().ConfigureAwait(false); //Wait for tasks to complete var heartbeatTask = _heartbeatTask; if (heartbeatTask != null) { await heartbeatTask.ConfigureAwait(false); } _heartbeatTask = null; ConnectionState = ConnectionState.Disconnected; await _audioLogger.InfoAsync("Disconnected").ConfigureAwait(false); await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false); }
private async Task <System.IO.Stream> SendInternalAsync(string method, string endpoint, RestRequest request) { if (!request.Options.IgnoreState) { CheckLoginState(); } //if (request.Options.RetryMode == null) // request.Options.RetryMode = DefaultRetryMode; var stopwatch = Stopwatch.StartNew(); var response = await request.SendAsync().ConfigureAwait(false); stopwatch.Stop(); double milliseconds = ToMilliseconds(stopwatch); await _sentRequestEvent.InvokeAsync(method, endpoint, milliseconds).ConfigureAwait(false); switch ((int)response.StatusCode) { case 200: // Ok break; case 204: // No Content case 400: // Bad Request case 401: // Unauthorized case 404: // Not found case 422: // Unprocessable Entity default: // Unrecognized code var error = DeserializeJson <Error>(response.Body); throw new HttpException(response.StatusCode, error.GetErrorMessage().Message); } return(response.Body); }
private async Task OnDocumentsSavedAsync(ICollection <T> documents, ICollection <T> originalDocuments, bool sendNotifications) { var modifiedDocs = originalDocuments.FullOuterJoin( documents, cf => cf.Id, cf => cf.Id, (original, modified, id) => new { Id = id, Original = original, Modified = modified }).Select(m => new ModifiedDocument <T>(m.Modified, m.Original)).ToList(); // if we couldn't find an original document, then it must be new. var addedDocs = modifiedDocs.Where(m => m.Original == null).Select(m => m.Value).ToList(); if (addedDocs.Count > 0) { await OnDocumentsAddedAsync(addedDocs, sendNotifications).AnyContext(); } var savedDocs = modifiedDocs.Where(m => m.Original != null).ToList(); if (savedDocs.Count == 0) { return; } if (DocumentsSaved != null) { await DocumentsSaved.InvokeAsync(this, new ModifiedDocumentsEventArgs <T>(modifiedDocs, this)).AnyContext(); } await OnDocumentsChangedAsync(ChangeType.Saved, savedDocs).AnyContext(); if (sendNotifications) { await SendNotificationsAsync(ChangeType.Saved, savedDocs).AnyContext(); } }
private async Task SendGatewayInternalAsync(GatewayOpCode opCode, object payload, RequestOptions options) { CheckState(); //TODO: Add ETF byte[] bytes = null; payload = new SocketFrame { Operation = (int)opCode, Payload = payload }; if (payload != null) { bytes = Encoding.UTF8.GetBytes(SerializeJson(payload)); } options.IsGatewayBucket = true; if (options.BucketId == null) { options.BucketId = GatewayBucket.Get(GatewayBucketType.Unbucketed).Id; } await RequestQueue.SendAsync(new WebSocketRequest(WebSocketClient, bytes, true, opCode == GatewayOpCode.Heartbeat, options)).ConfigureAwait(false); await _sentGatewayMessageEvent.InvokeAsync(opCode).ConfigureAwait(false); #if DEBUG_PACKETS Console.WriteLine($"-> {opCode}:\n{SerializeJson(payload)}"); #endif }
private void ChatMessageEvetRiser() { Task.Factory.StartNew(async() => { if (_FFChatMessageArrived.HandlersCount == 0) { SpinWait.SpinUntil(() => _FFChatMessageArrived.HandlersCount > 0); } while (_KeepWorking) { try { FFChatMsg ffChatMsg = new FFChatMsg(); if (_FFxivChat.TryDequeue(out ffChatMsg)) { var ea = new ChatMessageArrivedEventArgs(this) { ChatMessage = ffChatMsg }; await _FFChatMessageArrived.InvokeAsync(ea); } else { SpinWait.SpinUntil(() => _FFxivChat.IsEmpty == false && _KeepWorking == true); } } catch (Exception e) { Logger.WriteLog(e); } } }, TaskCreationOptions.LongRunning); }
private void OnGlobalHotKeyPressed(object sender, GlobalHotKeyEventArgs e) { if (ShowHideChatKeys != null) { if (e.HotKey.Name == ShowHideChatKeys.Name) { if (this.IsWindowVisible) { IsHiddenByUser = true; } else { IsHiddenByUser = false; } IsWindowVisible = !IsWindowVisible; } } if (ClickThoughtChatKeys != null) { if (e.HotKey.Name == ClickThoughtChatKeys.Name) { IsClickThrough = !IsClickThrough; } } if (ClearChatKeys != null) { if (e.HotKey.Name == ClearChatKeys.Name) { _RequestChatClear.InvokeAsync(new TatruEventArgs(this)); } } }
private async Task OnBeforeQueryAsync(IRepositoryQuery query, ICommandOptions options, Type resultType) { if (SupportsSoftDeletes && IsCacheEnabled && options.GetSoftDeleteMode() == SoftDeleteQueryMode.ActiveOnly) { var deletedIds = await Cache.GetListAsync <string>("deleted").AnyContext(); if (deletedIds.HasValue) { query.ExcludedId(deletedIds.Value); } } var systemFilter = query.GetSystemFilter(); if (systemFilter != null) { query.MergeFrom(systemFilter.GetQuery()); } if (BeforeQuery == null || !BeforeQuery.HasHandlers) { return; } await BeforeQuery.InvokeAsync(this, new BeforeQueryEventArgs <T>(query, options, this, resultType)).AnyContext(); }
/// <summary> Creates a new Webhook discord client. </summary> public DiscordWebhookClient(ulong webhookId, string webhookToken, DiscordRestConfig config) { _webhookId = webhookId; ApiClient = CreateApiClient(config); LogManager = new LogManager(config.LogLevel); LogManager.Message += async msg => await _logEvent.InvokeAsync(msg).ConfigureAwait(false); _restLogger = LogManager.CreateLogger("Rest"); ApiClient.RequestQueue.RateLimitTriggered += async(id, info) => { if (info == null) { await _restLogger.VerboseAsync($"Preemptive Rate limit triggered: {id ?? "null"}").ConfigureAwait(false); } else { await _restLogger.WarningAsync($"Rate limit triggered: {id ?? "null"}").ConfigureAwait(false); } }; ApiClient.SentRequest += async(method, endpoint, millis) => await _restLogger.VerboseAsync($"{method} {endpoint}: {millis} ms").ConfigureAwait(false); ApiClient.LoginAsync(TokenType.Webhook, webhookToken).GetAwaiter().GetResult(); }
protected virtual async Task OnCompletedAsync(IQueueEntry <T> entry) { var now = SystemClock.UtcNow; LastDequeueActivity = now; if (entry is QueueEntry <T> metadata) { if (metadata.EnqueuedTimeUtc > DateTime.MinValue) { metadata.TotalTime = now.Subtract(metadata.EnqueuedTimeUtc); } if (metadata.DequeuedTimeUtc > DateTime.MinValue) { metadata.ProcessingTime = now.Subtract(metadata.DequeuedTimeUtc); } } if (Completed != null) { var args = new CompletedEventArgs <T> { Queue = this, Entry = entry }; await Completed.InvokeAsync(this, args).AnyContext(); } StopProcessQueueEntryActivity(entry); }
private async Task ProcessVoicePacket(byte[] data) { if (data.Length < 13) // minimum packet length { return; } try { var pcm = new byte[AudioFormat.CalculateMaximumFrameSize()]; var pcmMem = pcm.AsMemory(); var opus = new byte[pcm.Length]; var opusMem = opus.AsMemory(); var pcmFillers = new List <ReadOnlyMemory <byte> >(); if (!ProcessPacket(data, ref opusMem, ref pcmMem, pcmFillers, out var vtx, out var audioFormat)) { return; } foreach (var pcmFiller in pcmFillers) { await _voiceReceived.InvokeAsync(new VoiceReceiveEventArgs(Discord) { SSRC = vtx.SSRC, UserId = vtx.UserId, PcmData = pcmFiller, OpusData = new byte[0].AsMemory(), AudioFormat = audioFormat, AudioDuration = audioFormat.CalculateSampleDuration(pcmFiller.Length) }).ConfigureAwait(false); } await _voiceReceived.InvokeAsync(new VoiceReceiveEventArgs(Discord) { SSRC = vtx.SSRC, UserId = vtx.UserId, PcmData = pcmMem, OpusData = opusMem, AudioFormat = audioFormat, AudioDuration = audioFormat.CalculateSampleDuration(pcmMem.Length) }).ConfigureAwait(false); } catch (Exception ex) { Discord.DebugLogger.LogMessage(LogLevel.Error, "VNext RX", "Exception occured when decoding incoming audio data", DateTime.Now, ex); } }
public DiscordSocketApiClient(RestClientProvider restClientProvider, WebSocketProvider webSocketProvider, string userAgent, string url = null, RetryMode defaultRetryMode = RetryMode.AlwaysRetry, JsonSerializer serializer = null, RateLimitPrecision rateLimitPrecision = RateLimitPrecision.Second, bool useSystemClock = true) : base(restClientProvider, userAgent, defaultRetryMode, serializer, rateLimitPrecision, useSystemClock) { _gatewayUrl = url; if (url != null) _isExplicitUrl = true; WebSocketClient = webSocketProvider(); //WebSocketClient.SetHeader("user-agent", DiscordConfig.UserAgent); (Causes issues in .NET Framework 4.6+) WebSocketClient.BinaryMessage += async (data, index, count) => { using (var decompressed = new MemoryStream()) { if (data[0] == 0x78) { //Strip the zlib header _compressed.Write(data, index + 2, count - 2); _compressed.SetLength(count - 2); } else { _compressed.Write(data, index, count); _compressed.SetLength(count); } //Reset positions so we don't run out of memory _compressed.Position = 0; _decompressor.CopyTo(decompressed); _compressed.Position = 0; decompressed.Position = 0; using (var reader = new StreamReader(decompressed)) using (var jsonReader = new JsonTextReader(reader)) { var msg = _serializer.Deserialize<SocketFrame>(jsonReader); if (msg != null) await _receivedGatewayEvent.InvokeAsync((GatewayOpCode)msg.Operation, msg.Sequence, msg.Type, msg.Payload).ConfigureAwait(false); } } }; WebSocketClient.TextMessage += async text => { using (var reader = new StringReader(text)) using (var jsonReader = new JsonTextReader(reader)) { var msg = _serializer.Deserialize<SocketFrame>(jsonReader); if (msg != null) await _receivedGatewayEvent.InvokeAsync((GatewayOpCode)msg.Operation, msg.Sequence, msg.Type, msg.Payload).ConfigureAwait(false); } }; WebSocketClient.Closed += async ex => { await DisconnectAsync().ConfigureAwait(false); await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false); }; }
private void OnPropertyChanged([CallerMemberName] string prop = "") { var ea = new AsyncPropertyChangedEventArgs(this, prop); _AsyncPropertyChanged.InvokeAsync(ea).Forget(); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(prop)); }
public async Task SendAsync(byte[] data, int bytes) { if (_udpEndpoint != null) { await _udp.SendAsync(data, bytes, _udpEndpoint).ConfigureAwait(false); await _sentDataEvent.InvokeAsync(bytes).ConfigureAwait(false); } }
public async void AsyncEventSyncHandler() { var counter = 0; void MyMethod() => counter++; var ev = new AsyncEvent <EventArgs>(); ev.Subscribe(MyMethod); await ev.InvokeAsync(this, new EventArgs()); Assert.Equal(1, counter); ev.Unsubscribe(MyMethod); await ev.InvokeAsync(this, new EventArgs()); Assert.Equal(1, counter); }
private async Task OnDocumentsChangedAsync(ChangeType changeType, ICollection <ModifiedDocument <T> > documents) { if (DocumentsChanged == null) { return; } await DocumentsChanged.InvokeAsync(this, new DocumentsChangeEventArgs <T>(changeType, documents, this)).AnyContext(); }
internal BaseTwitchClient(TwitchConfig config, TwitchRestApiClient client) { ApiClient = client; LogManager = new LogManager(config.LogLevel); LogManager.Message += async msg => await _logEvent.InvokeAsync(msg).ConfigureAwait(false); _stateLock = new SemaphoreSlim(1, 1); RestLogger = LogManager.CreateLogger("Rest"); ApiClient.SentRequest += async(method, endpoint, ms) => await RestLogger.VerboseAsync($"{method} /{endpoint}: {ms} ms"); }
public async Task SendSocketAsync(string command, string parameters, string tags = null, RequestOptions options = null) { CheckLoginState(); options = options ?? new RequestOptions(); var request = new ChatRequest(SocketClient, $"{tags}{command} {parameters}".Trim(), options); await request.SendAsync().ConfigureAwait(false); await _sentChatMessageEvent.InvokeAsync(command).ConfigureAwait(false); }
public DiscordRpcApiClient(string clientId, string userAgent, string origin, RestClientProvider restClientProvider, WebSocketProvider webSocketProvider, RetryMode defaultRetryMode = RetryMode.AlwaysRetry, JsonSerializer serializer = null) : base(restClientProvider, userAgent, defaultRetryMode, serializer) { _connectionLock = new SemaphoreSlim(1, 1); _clientId = clientId; _origin = origin; _requests = new ConcurrentDictionary <Guid, RpcRequest>(); _webSocketClient = webSocketProvider(); //_webSocketClient.SetHeader("user-agent", DiscordConfig.UserAgent); (Causes issues in .Net 4.6+) _webSocketClient.SetHeader("origin", _origin); _webSocketClient.BinaryMessage += async(data, index, count) => { using (var compressed = new MemoryStream(data, index + 2, count - 2)) using (var decompressed = new MemoryStream()) { using (var zlib = new DeflateStream(compressed, CompressionMode.Decompress)) zlib.CopyTo(decompressed); decompressed.Position = 0; using (var reader = new StreamReader(decompressed)) using (var jsonReader = new JsonTextReader(reader)) { var msg = _serializer.Deserialize <API.Rpc.RpcFrame>(jsonReader); await _receivedRpcEvent.InvokeAsync(msg.Cmd, msg.Event, msg.Data).ConfigureAwait(false); if (msg.Nonce.IsSpecified && msg.Nonce.Value.HasValue) { ProcessMessage(msg); } } } }; _webSocketClient.TextMessage += async text => { using (var reader = new StringReader(text)) using (var jsonReader = new JsonTextReader(reader)) { var msg = _serializer.Deserialize <API.Rpc.RpcFrame>(jsonReader); await _receivedRpcEvent.InvokeAsync(msg.Cmd, msg.Event, msg.Data).ConfigureAwait(false); if (msg.Nonce.IsSpecified && msg.Nonce.Value.HasValue) { ProcessMessage(msg); } } }; _webSocketClient.Closed += async ex => { await DisconnectAsync().ConfigureAwait(false); await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false); }; }
public async void RunAsyncEvent() { var x1 = new AsyncEvent(); x1.Subscribe(AddTask); var x2 = new AsyncEvent(); x2.Subscribe(x1); await x2.InvokeAsync(this, new EventArgs()).ConfigureAwait(false); await x2.InvokeAsync(this, new EventArgs()).ConfigureAwait(false); Assert.Equal(2, _counter); x2.Unsubscribe(x1); await x2.InvokeAsync(this, new EventArgs()).ConfigureAwait(false); await x2.InvokeAsync(this, new EventArgs()).ConfigureAwait(false); Assert.Equal(2, _counter); }
//Udp public async Task SendDiscoveryAsync(uint ssrc) { byte[] packet = new byte[70]; packet[0] = (byte)(ssrc >> 24); packet[1] = (byte)(ssrc >> 16); packet[2] = (byte)(ssrc >> 8); packet[3] = (byte)(ssrc >> 0); await SendAsync(packet, 0, 70).ConfigureAwait(false); await _sentDiscoveryEvent.InvokeAsync().ConfigureAwait(false); }
private async Task OnDocumentsRemovingAsync(ICollection <T> documents) { await InvalidateCacheAsync(documents).AnyContext(); if (DocumentsRemoving != null) { await DocumentsRemoving.InvokeAsync(this, new DocumentsEventArgs <T>(documents, this)).AnyContext(); } await OnDocumentsChangingAsync(ChangeType.Removed, documents).AnyContext(); }
private async Task SendGatewayInternalAsync(GatewayOpCode opCode, object payload, RequestOptions options) { CheckState(); //TODO: Add ETF byte[] bytes = null; payload = new SocketFrame { Operation = (int)opCode, Payload = payload }; if (payload != null) bytes = Encoding.UTF8.GetBytes(SerializeJson(payload)); await RequestQueue.SendAsync(new WebSocketRequest(WebSocketClient, null, bytes, true, options)).ConfigureAwait(false); await _sentGatewayMessageEvent.InvokeAsync(opCode).ConfigureAwait(false); }
public async void AsyncEventDispatches() { var counter = 0; var ev = new AsyncEvent(); Task MyMethod() { counter++; return(Task.CompletedTask); } ev.Subscribe(MyMethod); await ev.InvokeAsync(this, new EventArgs()); Assert.Equal(1, counter); ev.Unsubscribe(MyMethod); await ev.InvokeAsync(this, new EventArgs()); Assert.Equal(1, counter); }
public async Task LogAsync(LogSeverity severity, string source, string message, Exception ex = null) { if (severity <= Level) { await _messageEvent.InvokeAsync(new LogMessage(severity, source, message, ex)).ConfigureAwait(false); } }
internal DiscordVoiceAPIClient(ulong guildId, WebSocketProvider webSocketProvider, JsonSerializer serializer = null) { GuildId = guildId; _connectionLock = new SemaphoreSlim(1, 1); _udp = new UdpClient(new IPEndPoint(IPAddress.Any, 0)); _webSocketClient = webSocketProvider(); //_gatewayClient.SetHeader("user-agent", DiscordConfig.UserAgent); (Causes issues in .Net 4.6+) _webSocketClient.BinaryMessage += async(data, index, count) => { using (var compressed = new MemoryStream(data, index + 2, count - 2)) using (var decompressed = new MemoryStream()) { using (var zlib = new DeflateStream(compressed, CompressionMode.Decompress)) zlib.CopyTo(decompressed); decompressed.Position = 0; using (var reader = new StreamReader(decompressed)) { var msg = JsonConvert.DeserializeObject <WebSocketMessage>(reader.ReadToEnd()); await _receivedEvent.InvokeAsync((VoiceOpCode)msg.Operation, msg.Payload).ConfigureAwait(false); } } }; _webSocketClient.TextMessage += async text => { var msg = JsonConvert.DeserializeObject <WebSocketMessage>(text); await _receivedEvent.InvokeAsync((VoiceOpCode)msg.Operation, msg.Payload).ConfigureAwait(false); }; _webSocketClient.Closed += async ex => { await DisconnectAsync().ConfigureAwait(false); await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false); }; _serializer = serializer ?? new JsonSerializer { ContractResolver = new DiscordContractResolver() }; }