/// <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; }