private async Task GetActivityStats() { if (string.IsNullOrWhiteSpace(_rconPassword) || string.IsNullOrWhiteSpace(_rconHost) || _rconPort <= 0) { return; } try { var status = await RCON.UDPSendCommand("status", _rconHost, _rconPassword, _rconPort); var serverStatus = new ServerStatus(status); var activity = new Game($"{serverStatus.Players.Count}", ActivityType.Playing, ActivityProperties.Play); await _discord.SetActivityAsync(activity); _currentActivity = activity; AsyncUtilities.DelayAction(TimeSpan.FromMinutes(1), async _ => { await GetActivityStats(); }); } catch (Exception e) { _logger.LogError(e, e.Message); } }
public void TriggerDelayedRconNotification(PickupQueue queue) { // 2 minute delay message AsyncUtilities.DelayAction(TimeSpan.FromMinutes(2), async t => { await TriggerRconNotification(queue); }); // 4 minute delay message AsyncUtilities.DelayAction(TimeSpan.FromMinutes(4), async t => { await TriggerRconNotification(queue); }); }
public static void AutoRemoveMessage(this IUserMessage message, int delay = 30) { if (delay <= 0 || message == null) { return; //do nothing } AsyncUtilities.DelayAction(TimeSpan.FromSeconds(delay), async _ => { await message.DeleteAsync().ConfigureAwait(false); }); }
private async Task ReactionAddedAsync(Cacheable <IUserMessage, ulong> message, Cacheable <IMessageChannel, ulong> channel, SocketReaction reaction) { if (_translationService == null) { return; } if (channel.Value == null) { await channel.GetOrDownloadAsync(); } var msg = await message.GetOrDownloadAsync(); var messageText = msg?.Resolve(); var targetLanguage = _translationService.GetTargetLanguage(reaction.Emote.Name); if (string.IsNullOrWhiteSpace(messageText) || string.IsNullOrEmpty(targetLanguage)) { return; } var translations = (await _translationService.Translate(targetLanguage, messageText, "Original message") ?? await _translationService.Translate(targetLanguage, messageText, "Original message")).ToList(); if (!translations.Any()) { return; } var userName = (msg.Author as IGuildUser)?.Nickname ?? (msg.Author as IGuildUser)?.Username ?? msg.Author.Username; var sentMessage = await channel.Value.SendMessageAsync(embed : new EmbedBuilder { Author = new EmbedAuthorBuilder { IconUrl = msg.Author.GetAvatarUrl(), Name = userName }, Description = $"{translations.FirstOrDefault()?.TranslatedText}{Environment.NewLine + Environment.NewLine}" + $"[{translations.LastOrDefault()?.TranslatedText} :arrow_up:]({msg.GetJumpUrl()})", Color = Color.DarkBlue, Footer = new EmbedFooterBuilder { Text = $"Translation provided by Google Translate and pickup-bot.{Environment.NewLine}" + $"This message will self destruct in 30 seconds." } }.Build()); AsyncUtilities.DelayAction(TimeSpan.FromSeconds(30), async t => { await sentMessage.DeleteAsync(); }); }
private void UpdateActvity() { if (string.IsNullOrWhiteSpace(_rconPassword) || string.IsNullOrWhiteSpace(_rconHost) || _rconPort <= 0) { return; } _currentActivity = _discord.Activity; AsyncUtilities.DelayAction(TimeSpan.FromSeconds(15), async _ => { await _discord.SetActivityAsync(_currentActivity); UpdateActvity(); }); }
public void TestBasics() { const string MODULE_NAME = "module"; const int MODULE_COUNT = 10; const int EP_COUNT = 10; const string MSG = "MESSAGE"; ModuleManager manager = new(); MockBaseModule baseModule = new(); MessagingModule messageModule = new(); List <MockModule> handlerModules = new(); int i; for (i = 0; i < MODULE_COUNT; i++) { handlerModules.Add(new(MODULE_NAME + i)); } baseModule.MockProtocol.DelayTime = 0; for (i = 0; i < MODULE_COUNT / 2; i++) { TestUtils.AssertTask(manager.RegisterModuleAsync(handlerModules[i].Header)); } TestUtils.AssertTask(manager.RegisterModuleAsync(baseModule.Header)); TestUtils.AssertTask(manager.RegisterModuleAsync(messageModule.Header)); for (; i < MODULE_COUNT; i++) { TestUtils.AssertTask(manager.RegisterModuleAsync(handlerModules[i].Header)); } BroadcastMessenger messenger = TestUtils.AssertTask(manager.GetInterfaceAsync <BroadcastMessenger>(null)); ConcurrentBag <MockEndpoint> endpoints = new(); TestUtils.AssertTask(AsyncUtilities.RepeatAsync(() => { var ep = new MockEndpoint(); baseModule.ConnectEndpoint(ep); endpoints.Add(ep); return(Task.CompletedTask); }, EP_COUNT)); ConcurrentDictionary <Tuple <MockMessageHandler, MockEndpoint>, Message> msgDic = new(); baseModule.MockProtocol.MessageErrorHandler = async error => { Assert.IsFalse(true, "should never be reached!"); }; AsyncBarrier barrier = new(EP_COUNT * MODULE_COUNT, false); AsyncInt c = 0; //send a message to each handler via each endpoint foreach (var module in handlerModules) { module.Handler.MessageHandlerCallback = async(handler, ep, msg) => { Message expectedMsg; Assert.IsTrue(msgDic.TryGetValue((handler, (MockEndpoint)ep).ToTuple(), out expectedMsg)); Assert.AreEqual(expectedMsg, msg); await barrier.SignalAsync(); }; AsyncUtilities.ForEachAsync(async ep => { Message msg = new Message(module.Handler.Module, MSG_TYPE1, MSG + c.PostIncrement()); Assert.IsTrue(msgDic.TryAdd((module.Handler, ep).ToTuple(), msg)); await ep.SendAsync(msg); }, endpoints); } TestUtils.AssertTask(barrier.WaitAsync(), 1000000); }
public void TestConnectionProcessor() { const int COUNT = 10; SemaphoreSlim sem = new(1, 1); ModuleManager manager = new(); MockBaseModule baseModule = new(); ConnectionModule connectionModule = new(); MockClientProcessorModule processorModuleA = new(); MockClientProcessorModule processorModuleB = new(); TestUtils.AssertTask(manager.RegisterModuleAsync(baseModule.Header)); TestUtils.AssertTask(manager.RegisterModuleAsync(connectionModule.Header)); TestUtils.AssertTask(manager.RegisterModuleAsync(processorModuleA.Header)); TestUtils.AssertTask(manager.RegisterModuleAsync(processorModuleB.Header)); AsyncBarrier barrier = new(2 * COUNT, false); //connect multiple endpoints with 2 managed interfaces processorModuleA.DisconnectHandler = c => { Assert.IsTrue(false); return(Task.CompletedTask); }; processorModuleA.SynchronizeHandler = async c => { await barrier.SignalAsync(); }; processorModuleB.DisconnectHandler = c => { Assert.IsTrue(false); return(Task.CompletedTask); }; processorModuleB.SynchronizeHandler = async c => { await barrier.SignalAsync(); }; List <MockEndpoint> endpoints = new(); TestUtils.AssertTask(AsyncUtilities.RepeatAsync(async() => { var ep = new MockEndpoint(); await sem.WaitAsync(); endpoints.Add(ep); sem.Release(); baseModule.ConnectEndpoint(ep); }, COUNT), 1000); TestUtils.AssertTask(barrier.WaitAsync(), 1000); //disconnect one endpoint with 2 managed interfaces barrier = new(2, false); processorModuleA.DisconnectHandler = async c => { await barrier.SignalAsync(); }; processorModuleA.SynchronizeHandler = c => { Assert.IsTrue(false); return(Task.CompletedTask); }; processorModuleB.DisconnectHandler = async c => { await barrier.SignalAsync(); }; processorModuleB.SynchronizeHandler = c => { Assert.IsTrue(false); return(Task.CompletedTask); }; endpoints.First().Disconnect(true); TestUtils.AssertTask(barrier.WaitAsync()); endpoints.Remove(endpoints.First()); //disconnect all remaining endpoints after unregistering one of the managed interfaces TestUtils.AssertTask(manager.UnregisterModuleAsync(processorModuleB.Header)); processorModuleB.DisconnectHandler = c => { Assert.IsTrue(false); return(Task.CompletedTask); }; barrier = new(COUNT - 1, false); TestUtils.AssertTask(AsyncUtilities.ForEachAsync((ep) => { ep.Disconnect(true); return(Task.CompletedTask); }, endpoints), 1000); TestUtils.AssertTask(barrier.WaitAsync()); }