private async Task <HttpResponseMessage> GetResponseMessageAsync(FeignClientRequest request) { try { return(await SendAsyncInternal(request)); } catch (TerminatedRequestException) { if (IsResponseTerminatedRequest) { return(null); } throw; } catch (Exception ex) { #region ErrorRequest ErrorRequestEventArgs errorArgs = new ErrorRequestEventArgs(this, ex); OnErrorRequest(errorArgs); if (errorArgs.ExceptionHandled) { return(null); } #endregion throw; } }
public FallbackRequestEventArgs(IFeignClient feignClient, FeignClientRequest request, object fallback, IFallbackProxy fallbackProxy, MethodInfo method) : base(feignClient) { Request = request; Fallback = fallback; FallbackProxy = fallbackProxy; _method = method; }
private void EnsureSuccess(FeignClientRequest request, HttpResponseMessage responseMessage) { if (!responseMessage.IsSuccessStatusCode) { string content = responseMessage.Content.ReadAsStringAsync().GetResult(); _logger?.LogError($"request on \"{responseMessage.RequestMessage.RequestUri.ToString()}\" status code : " + responseMessage.StatusCode.GetHashCode() + " content : " + content); throw new FeignHttpRequestException(this, responseMessage.RequestMessage as FeignHttpRequestMessage, new HttpRequestException($"Response status code does not indicate success: {responseMessage.StatusCode.GetHashCode()} ({responseMessage.ReasonPhrase}).\r\nContent : {content}")); } }
private Task <HttpResponseMessage> SendAsyncInternal(FeignClientRequest request) { HttpMethod httpMethod = GetHttpMethod(request.HttpMethod); HttpRequestMessage httpRequestMessage = CreateRequestMessage(request, httpMethod, CreateUri(BuildUri(request.Uri))); // if support content if (httpMethod == HttpMethod.Post || httpMethod == HttpMethod.Put) { HttpContent httpContent = request.GetHttpContent(); if (httpContent != null) { httpRequestMessage.Content = httpContent; } } return(HttpClient.SendAsync(httpRequestMessage)); }
bool InvokeFallbackRequestPipeline(FeignClientRequest request, Delegate @delegate) { IFallbackProxy fallbackProxy = @delegate.Target as IFallbackProxy; FallbackRequestEventArgs eventArgs; if (fallbackProxy == null) { //可能因为method parameters length=0 , 故没有生成匿名调用类 eventArgs = new FallbackRequestEventArgs(this, request, _fallback, null, @delegate.Method); } else { eventArgs = new FallbackRequestEventArgs(this, request, _fallback, fallbackProxy, null); } OnFallbackRequest(eventArgs); return(eventArgs.IsTerminated); }
private async Task <TResult> GetResultAsync <TResult>(FeignClientRequest request, HttpResponseMessage responseMessage) { if (responseMessage == null) { return(default(TResult)); } #region ReceivingResponse ReceivingResponseEventArgs <TResult> receivingResponseEventArgs = new ReceivingResponseEventArgs <TResult>(this, responseMessage); _globalFeignClientPipeline?.GetServicePipeline(this.ServiceId)?.OnReceivingResponse(this, receivingResponseEventArgs); _globalFeignClientPipeline?.OnReceivingResponse(this, receivingResponseEventArgs); //if (receivingResponseEventArgs.Result != null) if (receivingResponseEventArgs._isSetResult) { return(receivingResponseEventArgs.GetResult <TResult>()); } #endregion await EnsureSuccessAsync(request, responseMessage); if (typeof(TResult) == typeof(Task)) { #if NET45 return((TResult)(object)Task.FromResult <object>(null)); #endif #if NETSTANDARD return((TResult)(object)Task.CompletedTask); #endif } if (typeof(TResult) == typeof(string)) { return((TResult)(object)await responseMessage.Content.ReadAsStringAsync()); } IMediaTypeFormatter mediaTypeFormatter = _feignOptions.MediaTypeFormatters.FindFormatter(responseMessage.Content.Headers.ContentType?.MediaType); if (mediaTypeFormatter == null) { throw new FeignHttpRequestException(this, responseMessage.RequestMessage as FeignHttpRequestMessage, new HttpRequestException($"Content type '{responseMessage.Content.Headers.ContentType.ToString()}' not supported")); } return(mediaTypeFormatter.GetResult <TResult>(await responseMessage.Content.ReadAsByteArrayAsync(), FeignClientUtils.GetEncoding(responseMessage.Content.Headers.ContentType))); }
protected void Send(FeignClientRequest request, Action fallback) { try { Send(request); } catch (TerminatedRequestException) { return; } catch (Exception) { if (fallback == null) { throw; } if (InvokeFallbackRequestPipeline(request, fallback)) { throw; } fallback.Invoke(); } }
protected async Task <TResult> SendAsync <TResult>(FeignClientRequest request, Func <Task <TResult> > fallback) { try { return(await SendAsync <TResult>(request)); } catch (TerminatedRequestException) { return(default(TResult)); } catch (Exception) { if (fallback == null) { throw; } if (InvokeFallbackRequestPipeline(request, fallback)) { throw; } return(await fallback.Invoke()); } }
protected async Task SendAsync(FeignClientRequest request, Func <Task> fallback) { try { await SendAsync(request); } catch (TerminatedRequestException) { return; } catch (Exception) { if (fallback == null) { throw; } if (InvokeFallbackRequestPipeline(request, fallback)) { throw; } await fallback.Invoke(); } }
protected TResult Send <TResult>(FeignClientRequest request) { HttpResponseMessage response = GetResponseMessage(request); return(GetResult <TResult>(request, response)); }
protected void Send(FeignClientRequest request) { HttpResponseMessage response = GetResponseMessage(request); GetResult <string>(request, response); }
protected async Task <TResult> SendAsync <TResult>(FeignClientRequest request) { HttpResponseMessage response = await GetResponseMessageAsync(request); return(await GetResultAsync <TResult>(request, response)); }
private HttpRequestMessage CreateRequestMessage(FeignClientRequest request, HttpMethod method, Uri uri) { FeignHttpRequestMessage requestMessage = new FeignHttpRequestMessage(request, method, uri); return(requestMessage); }
protected async Task SendAsync(FeignClientRequest request) { HttpResponseMessage response = await GetResponseMessageAsync(request); await GetResultAsync <string>(request, response); }