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());
}
