/// <summary>
/// Generate request hash.
/// </summary>
/// <param name="request">Request to generate hash for.</param>
internal static string GenerateHash(this FluentHttpRequest request)
{
var options = request.GetRequestHashOptions();
var headers = new FluentHttpHeaders(request.Builder.DefaultHeaders)
.SetRange(request.Headers);
if (options?.HeadersExclude != null)
{
headers.WithOptions(opts => opts.WithHashingExclude(options.HeadersExclude));
}
var headersHash = headers.ToHashString();
var uri = request.Uri.IsAbsoluteUri
? request.Uri
: new Uri($"{request.Builder.BaseUrl.TrimEnd('/')}/{request.Uri.ToString().TrimStart('/')}");
var uriHash = options?.UriManipulation == null
? uri.ToString()
: options.UriManipulation.Invoke(uri);
var contentHash = string.Empty;
if (request.Message.Content is ObjectContent c)
{
contentHash = options?.HashBody?.Invoke(c.Value) ?? JsonConvert.SerializeObject(c.Value);
}
return($"method={request.Method};url={uriHash};headers={headersHash};content={contentHash}");
}
/// <summary>
/// Build HTTP request.
/// </summary>
/// <returns>Return HTTP request instance.</returns>
public FluentHttpRequest Build()
{
ValidateRequest();
var uri = BuildUri(Uri, _queryParams, _lowerCaseQueryKeys);
var httpRequest = new HttpRequestMessage(HttpMethod, uri);
if (_httpBody != null)
{
httpRequest.Content = _httpBody;
}
if (Headers != null)
{
foreach (var header in Headers)
{
httpRequest.Headers.Add(header.Key, header.Value);
}
}
var fluentRequest = new FluentHttpRequest(httpRequest, Items)
{
HasSuccessStatusOrThrow = _hasSuccessStatusOrThrow,
CancellationToken = _cancellationToken,
Formatters = _fluentHttpClient.Formatters
};
return(fluentRequest);
}
/// <inheritdoc />
public async Task <FluentHttpResponse <T> > SendAsync <T>(FluentHttpRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var response = await _middlewareRunner.Run(request, async() =>
{
var result = await RawHttpClient.SendAsync(request.Message, request.CancellationToken)
.ConfigureAwait(false);
return(ToFluentResponse(result, request.Items));
}).ConfigureAwait(false);
if (HasSuccessStatusOrThrow && !request.HasSuccessStatusOrThrow.HasValue)
{
response.EnsureSuccessStatusCode();
}
if (request.HasSuccessStatusOrThrow.HasValue && request.HasSuccessStatusOrThrow.Value)
{
response.EnsureSuccessStatusCode();
}
if (!response.IsSuccessStatusCode)
{
return(new FluentHttpResponse <T>(response));
}
return(new FluentHttpResponse <T>(response)
{
Data = await response.As <T>()
});
}
/// <summary>
/// Get timer warn threshold option for the request.
/// </summary>
/// <param name="request">Request to get time from.</param>
/// <returns>Returns timespan for the time taken.</returns>
public static TimeSpan?GetTimerWarnThreshold(this FluentHttpRequest request)
{
if (request.Items.TryGetValue(WarnThresholdOptionKey, out var result))
{
return((TimeSpan)result);
}
return(null);
}
/// <summary>
/// Get request hash.
/// </summary>
/// <param name="request">Request to get hash from.</param>
/// <returns>Returns hash string for the request.</returns>
public static string GetHash(this FluentHttpRequest request)
{
if (request.Items.TryGetValue(HashKey, out var value))
{
return((string)value);
}
var valueStr = request.GenerateHash();
request.SetRequestHash(valueStr);
return(valueStr);
}
public void Push(string key, FluentHttpRequest request)
{
if (_contexts.TryGetValue(key, out var context))
{
context.Request = request;
return;
}
_contexts.Add(key, new FluentlyExecutionContext
{
Request = request
});
}
/// <summary>
/// Get logging option for the request.
/// </summary>
/// <param name="request">Request to get options from.</param>
/// <param name="defaultOptions"></param>
/// <returns>Returns merged logging options.</returns>
public static LoggerHttpMiddlewareOptions GetLoggingOptions(this FluentHttpRequest request, LoggerHttpMiddlewareOptions defaultOptions = null)
{
if (!request.Items.TryGetValue(LoggingOptionsKey, out var result))
{
return(defaultOptions);
}
var options = (LoggerHttpMiddlewareOptions)result;
if (defaultOptions == null)
{
return(options);
}
options.ShouldLogDetailedRequest = options.ShouldLogDetailedRequest ?? defaultOptions.ShouldLogDetailedRequest;
options.ShouldLogDetailedResponse = options.ShouldLogDetailedResponse ?? defaultOptions.ShouldLogDetailedResponse;
return(options);
}
/// <summary>
/// Get response caching options for the request.
/// </summary>
/// <param name="request">Request to get options from.</param>
/// <param name="defaultOptions"></param>
/// <returns>Returns merged logging options.</returns>
public static ResponseCacheHttpMiddlewareOptions GetResponseCachingOptions(this FluentHttpRequest request, ResponseCacheHttpMiddlewareOptions defaultOptions = null)
{
if (!request.Items.TryGetValue(OptionsKey, out var result))
{
return(defaultOptions);
}
var options = (ResponseCacheHttpMiddlewareOptions)result;
if (defaultOptions == null)
{
return(options);
}
options.Matcher = defaultOptions.Matcher;
options.IsWriteOnly = defaultOptions.IsWriteOnly;
return(options);
}
/// <inheritdoc />
public async Task <FluentHttpResponse> Send(FluentHttpRequest fluentRequest)
{
if (fluentRequest == null)
{
throw new ArgumentNullException(nameof(fluentRequest));
}
var response = await _middlewareRunner.Run(_middleware, fluentRequest, async request =>
{
var result = await RawHttpClient.SendAsync(request.Message, request.CancellationToken)
.ConfigureAwait(false);
return(ToFluentResponse(result, request.Items));
}).ConfigureAwait(false);
if (fluentRequest.HasSuccessStatusOrThrow)
{
response.EnsureSuccessStatusCode();
}
return(response);
}
/// <inheritdoc />
public async Task <FluentHttpResponse> Send(FluentHttpRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var requestId = request.Message.AddRequestId();
_requestTracker.Push(requestId, request);
await RawHttpClient.SendAsync(request.Message);
var executionContext = _requestTracker.Pop(requestId);
if (request.HasSuccessStatusOrThrow)
{
executionContext.Response.EnsureSuccessStatusCode();
}
return(executionContext.Response);
}
/// <summary>
/// Call FluentHttpRequest's FluentHttpClient SendAsync method.
/// </summary>
/// <typeparam name="T">Return type</typeparam>
/// <param name="request">FluentHttpRequest</param>
/// <returns>T</returns>
public static async Task <T> SendAsync <T>(this FluentHttpRequest request)
{
var response = await request.FluentHttpClient.SendAsync <T>(request);
return(response.Data);
}
/// <summary>
/// Get response caching options for the request.
/// </summary>
/// <param name="request">Request to get options from.</param>
public static RequestHashOptions GetRequestHashOptions(this FluentHttpRequest request)
{
request.Items.TryGetValue(HashOptionsKey, out var result);
return((RequestHashOptions)result);
}
public void Push(string key, FluentHttpRequest request)
{
var context = _contexts.GetOrAdd(key, _ => new FluentlyExecutionContext());
context.Request = request;
}
