/// <summary>
/// Entry point for a generic http request which reports on the request and tries with exponential back-off for transient failure.
/// </summary>
/// <param name="client"></param>
/// <param name="httpMethod"></param>
/// <param name="uri"></param>
/// <param name="webHookHeaders"></param>
/// <param name="payload"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task <HttpResponseMessage> SendRequestReliablyAsync(
this HttpClient client,
HttpMethod httpMethod,
Uri uri,
WebHookHeaders webHookHeaders,
string payload,
CancellationToken token = default)
{
var result = await RetryRequest(() =>
{
var request = new HttpRequestMessage(httpMethod, uri);
if (httpMethod != HttpMethod.Get)
{
request.Content = new StringContent(payload, Encoding.UTF8, webHookHeaders.ContentHeaders[Constants.Headers.ContentType]);
}
foreach (var key in webHookHeaders.RequestHeaders.Keys)
{
//todo is this the correct thing to do when there is a CorrelationVector with multiple Children.
if (request.Headers.Contains(key))
{
request.Headers.Remove(key);
}
request.Headers.Add(key, webHookHeaders.RequestHeaders[key]);
}
return(client.SendAsync(request, token));
});
return(result);
}
/// <inheritdoc />
public WebHookHeaders GetHttpHeaders(WebhookConfig webhookConfig, MessageData messageData)
{
if (webhookConfig == null)
{
throw new ArgumentNullException(nameof(webhookConfig));
}
if (messageData == null)
{
throw new ArgumentNullException(nameof(messageData));
}
var headers = new WebHookHeaders();
headers.AddContentHeader(Constants.Headers.ContentType, webhookConfig.ContentType);
headers.AddRequestHeader(Constants.Headers.CorrelationId, messageData.CorrelationId);
headers.AddRequestHeader(Constants.Headers.EventDeliveryId, messageData.CorrelationId);
headers.AddRequestHeader(Constants.Headers.EventType, webhookConfig.EventType);
return(headers);
}
public async Task LogAsync(
HttpClient httpClient,
HttpResponseMessage response,
MessageData messageData,
Uri uri,
HttpMethod httpMethod,
WebHookHeaders headers
)
{
_bigBrother.Publish(new WebhookEvent(
messageData.EventHandlerActorId,
messageData.Type,
$"Response status code {response.StatusCode}",
uri.AbsoluteUri,
httpMethod,
response.StatusCode,
messageData.CorrelationId));
//only log the failed requests in more depth, need to have a good think about this - debugging v privacy
if (response.IsSuccessStatusCode)
{
return;
}
_bigBrother.Publish(new FailedWebHookEvent(
httpClient.DefaultRequestHeaders.ToString(),
response.Headers.ToString(),
messageData.Payload ?? string.Empty,
await GetPayloadAsync(response),
messageData.EventHandlerActorId,
messageData.Type,
$"Response status code {response.StatusCode}",
uri.AbsoluteUri,
httpMethod,
response.StatusCode,
messageData.CorrelationId)
{
AuthToken = response.StatusCode == System.Net.HttpStatusCode.Unauthorized? headers?.RequestHeaders?[Constants.Headers.Authorization]: string.Empty
});
}
protected async Task AddAuthenticationHeaderAsync(CancellationToken cancellationToken, WebhookConfig config, WebHookHeaders webHookHeaders)
{
if (config.AuthenticationConfig.Type != AuthenticationType.None)
{
var acquireTokenHandler = await _authenticationHandlerFactory.GetAsync(config, cancellationToken);
var result = await acquireTokenHandler.GetTokenAsync(cancellationToken);
webHookHeaders.AddRequestHeader(Constants.Headers.Authorization, result);
}
}
