public async Task AddInvokationAsync(Guid webhookId, string dump, WebhookResult result, TimeSpan elapsed)
{
var webhookEntity = await Collection.Find(x => x.Id == webhookId).FirstOrDefaultAsync();
if (webhookEntity != null)
{
switch (result)
{
case WebhookResult.Success:
webhookEntity.TotalSucceeded++;
break;
case WebhookResult.Fail:
webhookEntity.TotalFailed++;
break;
case WebhookResult.Timeout:
webhookEntity.TotalTimedout++;
break;
}
webhookEntity.TotalRequestTime += (long)elapsed.TotalMilliseconds;
webhookEntity.LastDumps.Insert(0, dump);
while (webhookEntity.LastDumps.Count > MaxDumps)
{
webhookEntity.LastDumps.RemoveAt(webhookEntity.LastDumps.Count - 1);
}
await Collection.ReplaceOneAsync(x => x.Id == webhookId, webhookEntity);
}
}
public Task TraceSentAsync(Guid jobId, string dump, WebhookResult result, TimeSpan elapsed, Instant?nextAttempt)
{
WebhookJobResult jobResult;
if (result != WebhookResult.Success && nextAttempt == null)
{
jobResult = WebhookJobResult.Failed;
}
else if (result != WebhookResult.Success && nextAttempt.HasValue)
{
jobResult = WebhookJobResult.Retry;
}
else
{
jobResult = WebhookJobResult.Success;
}
return(Collection.UpdateOneAsync(x => x.Id == jobId,
Update.Set(x => x.Result, result)
.Set(x => x.LastDump, dump)
.Set(x => x.JobResult, jobResult)
.Set(x => x.IsSending, false)
.Set(x => x.NextAttempt, nextAttempt)
.Inc(x => x.NumCalls, 1)));
}
public async Task TraceSentAsync(Guid webhookId, WebhookResult result, TimeSpan elapsed)
{
var webhookEntity =
await Collection.Find(x => x.Id == webhookId)
.FirstOrDefaultAsync();
if (webhookEntity != null)
{
switch (result)
{
case WebhookResult.Success:
webhookEntity.TotalSucceeded++;
break;
case WebhookResult.Failed:
webhookEntity.TotalFailed++;
break;
case WebhookResult.Timeout:
webhookEntity.TotalTimedout++;
break;
}
webhookEntity.TotalRequestTime += (long)elapsed.TotalMilliseconds;
await Collection.ReplaceOneAsync(x => x.Id == webhookId, webhookEntity);
}
}
private async Task executeHandler(string requestBody, WebhookResult webhookResult, Type handlerType)
{
try
{
var handler = serviceProvider.GetRequiredService(handlerType) as EventHandlers.IGitHubEventHandler;
var handlerResult = await handler.Execute(requestBody);
webhookResult.LogInfo($"{handlerType.Name} -> {handlerResult.Result}");
}
catch (Exception ex)
{
webhookResult.LogError(ex, $"{handlerType.Name} -> exception");
}
}
public async Task Process(string gitHubEventName, string requestBody, WebhookResult webhookResult)
{
if (!this.handlers.TryGetValue(gitHubEventName, out var handlersForEvent))
{
webhookResult.LogInfo($"Event {gitHubEventName} is not of interest");
}
else
{
foreach (var handlerType in handlersForEvent)
{
await executeHandler(requestBody, webhookResult, handlerType);
}
}
}
private async Task executeHandler(string requestBody, WebhookResult webhookResult, Type handlerType, ILogger logger)
{
try
{
var handler = ActivatorUtilities.CreateInstance(serviceProvider, handlerType, logger) as EventHandlers.IGitHubEventHandler;
var handlerResult = await handler.Execute(requestBody);
logger.LogInformation($"{handlerType.Name} result: {handlerResult.Result}");
webhookResult.LogInfo($"{handlerType.Name} -> {handlerResult.Result}");
}
catch (Exception ex)
{
logger.LogError(ex, $"{handlerType.Name} execution failed");
webhookResult.LogError(ex, $"{handlerType.Name} -> exception");
}
}
public async Task EventDispatchServiceTest()
{
var sc = new ServiceCollection();
sc.AddSingleton <TestHandler>();
sc.AddSingleton <Test2Handler>();
var serviceProvider = sc.BuildServiceProvider();
var builder = new EventDispatchConfigBuilder(sc)
.Add <TestHandler>("invoke_test")
.Add <Test2Handler>("test2");
var dispatcher = new EventDispatchService(serviceProvider, builder);
var result1 = new WebhookResult();
await dispatcher.Process("invoke_test", string.Empty, result1);
var result2 = new WebhookResult();
await dispatcher.Process("test2", "test request body", result2);
Assert.IsTrue(result1.Messages.First().Contains("Test"));
Assert.IsTrue(result2.Messages.First().Contains("test request body"));
}
public Task Process(string githubEventName, string requestBody, WebhookResult webhookResult)
{
return(Task.Delay(0));
}
protected async Task TestWebhook()
{
WebhookResult = await WebhookTester.Test(FolderWebhook.CallbackUrl, System.Text.Json.JsonSerializer.Deserialize <object>(FolderWebhook.WebHookTypeMessageStructure));
}
private void SetupSender(IWebhookEventEntity @event, string requestDump, WebhookResult requestResult, TimeSpan requestTime)
{
A.CallTo(() => webhookSender.SendAsync(@event.Job))
.Returns((requestDump, requestResult, requestTime));
}
private void VerifyRepositories(IWebhookEventEntity @event, string requestDump, WebhookResult requestResult, TimeSpan requestTime, Instant?nextAttempt)
{
A.CallTo(() => webhookEventRepository.TraceSendingAsync(@event.Id))
.MustHaveHappened();
A.CallTo(() => webhookEventRepository.TraceSendingAsync(@event.Id))
.MustHaveHappened();
A.CallTo(() => webhookEventRepository.TraceSentAsync(@event.Id, requestDump, requestResult, requestTime, nextAttempt))
.MustHaveHappened();
A.CallTo(() => webhookRepository.TraceSentAsync(@event.Job.WebhookId, requestResult, requestTime))
.MustHaveHappened();
}
