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