public async Task HandleAsync(IRuleEventEntity @event)
{
if (!executing.TryAdd(@event.Id, false))
{
return;
}
try
{
var job = @event.Job;
var(response, elapsed) = await ruleService.InvokeAsync(job.ActionName, job.ActionData);
var jobInvoke = ComputeJobInvoke(response.Status, @event, job);
var jobResult = ComputeJobResult(response.Status, jobInvoke);
var now = clock.GetCurrentInstant();
await ruleEventRepository.MarkSentAsync(@event.Job, response.Dump, response.Status, jobResult, elapsed, now, jobInvoke);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "SendWebhookEvent")
.WriteProperty("status", "Failed"));
}
finally
{
executing.TryRemove(@event.Id, out _);
}
}
private void VerifyRepositories(IRuleEventEntity @event, string dump, RuleResult result, RuleJobResult jobResult, TimeSpan elapsed, Instant?nextCall)
{
A.CallTo(() => ruleEventRepository.MarkSendingAsync(@event.Id))
.MustHaveHappened();
A.CallTo(() => ruleEventRepository.MarkSentAsync(@event.Id, dump, result, jobResult, elapsed, nextCall))
.MustHaveHappened();
}
private async Task MakeRequestAsync(IRuleEventEntity @event)
{
try
{
var job = @event.Job;
var response = await ruleService.InvokeAsync(job.ActionName, job.ActionData);
Instant?nextCall = null;
if (response.Result != RuleResult.Success)
{
switch (@event.NumCalls)
{
case 0:
nextCall = job.Created.Plus(Duration.FromMinutes(5));
break;
case 1:
nextCall = job.Created.Plus(Duration.FromHours(1));
break;
case 2:
nextCall = job.Created.Plus(Duration.FromHours(6));
break;
case 3:
nextCall = job.Created.Plus(Duration.FromHours(12));
break;
}
}
RuleJobResult jobResult;
if (response.Result != RuleResult.Success && !nextCall.HasValue)
{
jobResult = RuleJobResult.Failed;
}
else if (response.Result != RuleResult.Success && nextCall.HasValue)
{
jobResult = RuleJobResult.Retry;
}
else
{
jobResult = RuleJobResult.Success;
}
await ruleEventRepository.MarkSentAsync(@event.Id, response.Dump, response.Result, jobResult, response.Elapsed, nextCall);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "SendWebhookEvent")
.WriteProperty("status", "Failed"));
throw;
}
}
public static RuleEventDto FromRuleEvent(IRuleEventEntity ruleEvent, ApiController controller, string app)
{
var result = new RuleEventDto();
SimpleMapper.Map(ruleEvent, result);
SimpleMapper.Map(ruleEvent.Job, result);
return(result.CreateLinks(controller, app));
}
public static RuleEventDto FromRuleEvent(IRuleEventEntity ruleEvent)
{
var response = new RuleEventDto();
SimpleMapper.Map(ruleEvent, response);
SimpleMapper.Map(ruleEvent.Job, response);
return(response);
}
public static RuleEventDto FromRuleEvent(IRuleEventEntity ruleEvent, Resources resources)
{
var result = new RuleEventDto();
SimpleMapper.Map(ruleEvent, result);
SimpleMapper.Map(ruleEvent.Job, result);
return(result.CreateLinks(resources));
}
private void SetupPendingEvents(IRuleEventEntity @event)
{
A.CallTo(() => ruleEventRepository.QueryPendingAsync(
now,
A <Func <IRuleEventEntity, Task> > .Ignored,
A <CancellationToken> .Ignored))
.Invokes(async(Instant n, Func <IRuleEventEntity, Task> callback, CancellationToken ct) =>
{
await callback(@event);
});
}
public async Task HandleAsync(IRuleEventEntity @event)
{
if (!executing.TryAdd(@event.Id, false))
{
return;
}
try
{
var job = @event.Job;
var(response, elapsed) = await ruleService.InvokeAsync(job.ActionName, job.ActionData);
var jobDelay = ComputeJobDelay(response.Status, @event, job);
var jobResult = ComputeJobResult(response.Status, jobDelay);
var now = clock.GetCurrentInstant();
var update = new RuleJobUpdate
{
Elapsed = elapsed,
ExecutionDump = response.Dump,
ExecutionResult = response.Status,
Finished = now,
JobNext = jobDelay,
JobResult = jobResult
};
await ruleEventRepository.UpdateAsync(@event.Job, update);
if (response.Status == RuleResult.Failed)
{
log.LogWarning(response.Exception !, w => w
.WriteProperty("action", "SendRuleEvent")
.WriteProperty("status", "Failed")
.WriteProperty("ruleId", @event.Job.RuleId.ToString())
.WriteProperty("ruleDescription", @event.Job.Description)
.WriteProperty("dump", response.Dump));
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "SendRuleEvent")
.WriteProperty("status", "Failed"));
}
finally
{
executing.TryRemove(@event.Id, out _);
}
}
public async Task HandleAsync(IRuleEventEntity @event)
{
if (!executing.TryAdd(@event.Id, false))
{
return;
}
try
{
var job = @event.Job;
var(response, elapsed) = await ruleService.InvokeAsync(job.ActionName, job.ActionData);
var jobDelay = ComputeJobDelay(response.Status, @event, job);
var jobResult = ComputeJobResult(response.Status, jobDelay);
var now = clock.GetCurrentInstant();
var update = new RuleJobUpdate
{
Elapsed = elapsed,
ExecutionDump = response.Dump,
ExecutionResult = response.Status,
Finished = now,
JobNext = jobDelay,
JobResult = jobResult
};
await ruleEventRepository.UpdateAsync(@event.Job, update);
if (response.Status == RuleResult.Failed)
{
log.LogWarning(response.Exception, "Failed to execute rule event with rule id {ruleId}/{description}: {dump}",
@event.Job.RuleId,
@event.Job.Description,
response.Dump);
}
}
catch (Exception ex)
{
log.LogError(ex, "Failed to execute rule event with internal error.");
}
finally
{
executing.TryRemove(@event.Id, out _);
}
}
private async Task <IRuleEventEntity> BlockAsync(IRuleEventEntity @event)
{
try
{
await ruleEventRepository.MarkSendingAsync(@event.Id);
return(@event);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "BlockWebhookEvent")
.WriteProperty("status", "Failed"));
throw;
}
}
private static Instant?ComputeJobInvoke(RuleResult result, IRuleEventEntity @event, RuleJob job)
{
if (result != RuleResult.Success)
{
switch (@event.NumCalls)
{
case 0:
return(job.Created.Plus(Duration.FromMinutes(5)));
case 1:
return(job.Created.Plus(Duration.FromHours(1)));
case 2:
return(job.Created.Plus(Duration.FromHours(6)));
case 3:
return(job.Created.Plus(Duration.FromHours(12)));
}
}
return(null);
}
private void SetupSender(IRuleEventEntity @event, string requestDump, RuleResult requestResult, TimeSpan requestTime)
{
A.CallTo(() => ruleService.InvokeAsync(@event.Job.ActionName, @event.Job.ActionData))
.Returns((requestDump, requestResult, requestTime));
}
