private HttpRequestMessage CreateRequestMessage(FeignClientHttpRequest request, HttpMethod method, Uri uri)
{
FeignHttpRequestMessage requestMessage = new FeignHttpRequestMessage(request, method, uri);
if (!string.IsNullOrWhiteSpace(request.Accept))
{
requestMessage.Headers.Accept.ParseAdd(request.Accept);
}
if (request.Headers != null && request.Headers.Length > 0)
{
foreach (var header in request.Headers)
{
string[] values = header.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (values.Length == 2)
{
requestMessage.Headers.TryAddWithoutValidation(values[0], values[1]);
}
}
}
if (request.RequestHeaderHandlers != null && request.RequestHeaderHandlers.Count > 0)
{
foreach (var handler in request.RequestHeaderHandlers)
{
handler.SetHeader(requestMessage);
}
}
return(requestMessage);
}
protected override Uri LookupRequestUri(FeignHttpRequestMessage requestMessage)
{
if (!ShouldResolveService)
{
return(requestMessage.RequestUri);
}
if (_serviceDiscovery == null)
{
ServiceResolveFail(requestMessage);
return(requestMessage.RequestUri);
}
IList <IServiceInstance> services = FeignClient.FeignOptions.DiscoverServiceCacheTime.HasValue ? _serviceDiscovery.GetServiceInstancesWithCache(requestMessage.RequestUri.Host, _serviceCacheProvider, FeignClient.FeignOptions.DiscoverServiceCacheTime.Value) : _serviceDiscovery.GetServiceInstances(requestMessage.RequestUri.Host);
if (services == null || services.Count == 0)
{
ServiceResolveFail(requestMessage);
}
return(_serviceResolve.ResolveService(requestMessage.RequestUri, services));
}
internal SendingRequestEventArgs(IFeignClient <TService> feignClient, FeignHttpRequestMessage requestMessage, CancellationToken cancellationToken) : base(feignClient)
{
RequestMessage = requestMessage;
_cancellationToken = cancellationToken;
}
void ServiceResolveFail(FeignHttpRequestMessage requestMessage)
{
throw new ServiceResolveFailException($"Resolve service fail : {requestMessage.RequestUri.ToString()}");
}
internal ErrorRequestEventArgs(IFeignClient <TService> feignClient, FeignHttpRequestMessage requestMessage, Exception exception) : base(feignClient)
{
RequestMessage = requestMessage;
Exception = exception;
}
private HttpRequestMessage CreateRequestMessage(FeignClientRequest request, HttpMethod method, Uri uri)
{
FeignHttpRequestMessage requestMessage = new FeignHttpRequestMessage(request, method, uri);
return(requestMessage);
}
async Task <HttpResponseMessage> SendInternalAsync(FeignHttpRequestMessage request, CancellationToken cancellationToken)
{
var current = request.RequestUri;
CancellationTokenSource cts = null;
try
{
#region BuildingRequest
BuildingRequestEventArgs <TService> buildingArgs = new BuildingRequestEventArgs <TService>(_feignClient, request.Method.ToString(), request.RequestUri, new Dictionary <string, string>(), request.FeignClientRequest);
_feignClient.OnBuildingRequest(buildingArgs);
//request.Method = new HttpMethod(buildingArgs.Method);
request.RequestUri = buildingArgs.RequestUri;
if (buildingArgs.Headers != null && buildingArgs.Headers.Count > 0)
{
foreach (var item in buildingArgs.Headers)
{
request.Headers.TryAddWithoutValidation(item.Key, item.Value);
}
}
#endregion
request.RequestUri = LookupRequestUri(request);
#region SendingRequest
SendingRequestEventArgs <TService> sendingArgs = new SendingRequestEventArgs <TService>(_feignClient, request, cancellationToken);
_feignClient.OnSendingRequest(sendingArgs);
if (sendingArgs.IsTerminated)
{
//请求被终止
throw new TerminatedRequestException();
}
if (sendingArgs._cancellationTokenSource != null)
{
cts = sendingArgs._cancellationTokenSource;
cancellationToken = cts.Token;
}
request = sendingArgs.RequestMessage;
if (request == null)
{
_logger?.LogError($"SendingRequest is null;");
return(new HttpResponseMessage(System.Net.HttpStatusCode.ExpectationFailed)
{
Content = new StringContent(""),
//Headers = new System.Net.Http.Headers.HttpResponseHeaders(),
RequestMessage = request
});
}
#endregion
#region CannelRequest
CancelRequestEventArgs <TService> cancelArgs = new CancelRequestEventArgs <TService>(_feignClient, request, cancellationToken);
_feignClient.OnCancelRequest(cancelArgs);
#endregion
return(await base.SendAsync(request, cancelArgs.CancellationToken)
#if CONFIGUREAWAIT_FALSE
.ConfigureAwait(false)
#endif
);
}
catch (Exception e)
{
if (!e.IsSkipLog())
{
_logger?.LogError(e, "Exception during SendAsync()");
}
if (e is HttpRequestException)
{
FeignHttpRequestException feignHttpRequestException = new FeignHttpRequestException(_feignClient, request, (HttpRequestException)e);
ExceptionDispatchInfo exceptionDispatchInfo = ExceptionDispatchInfo.Capture(feignHttpRequestException);
exceptionDispatchInfo.Throw();
}
throw;
}
finally
{
request.RequestUri = current;
if (cts != null)
{
cts.Dispose();
}
}
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
FeignHttpRequestMessage feignRequest = request as FeignHttpRequestMessage;
return(SendInternalAsync(feignRequest, cancellationToken));
}
/// <summary>
/// 查找服务路径
/// </summary>
/// <param name="requestMessage"></param>
/// <returns></returns>
protected virtual Uri LookupRequestUri(FeignHttpRequestMessage requestMessage)
{
return(requestMessage.RequestUri);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
FeignHttpRequestMessage feignRequest = request as FeignHttpRequestMessage;
var current = request.RequestUri;
try
{
#region BuildingRequest
BuildingRequestEventArgs buildingArgs = new BuildingRequestEventArgs(_feignClient, request.Method.ToString(), request.RequestUri, new Dictionary <string, string>());
_feignClient.OnBuildingRequest(buildingArgs);
//request.Method = new HttpMethod(buildingArgs.Method);
request.RequestUri = buildingArgs.RequestUri;
if (buildingArgs.Headers != null && buildingArgs.Headers.Count > 0)
{
foreach (var item in buildingArgs.Headers)
{
request.Headers.TryAddWithoutValidation(item.Key, item.Value);
}
}
#endregion
request.RequestUri = LookupRequestUri(request.RequestUri);
#region SendingRequest
SendingRequestEventArgs sendingArgs = new SendingRequestEventArgs(_feignClient, feignRequest);
_feignClient.OnSendingRequest(sendingArgs);
if (sendingArgs.IsTerminated)
{
throw new TerminatedRequestException();
}
request = sendingArgs.RequestMessage;
if (request == null)
{
_logger?.LogError($"SendingRequest is null;");
return(new HttpResponseMessage(System.Net.HttpStatusCode.ExpectationFailed)
{
Content = new StringContent(""),
//Headers = new System.Net.Http.Headers.HttpResponseHeaders(),
RequestMessage = request
});
}
#endregion
#region CannelRequest
CancelRequestEventArgs cancelArgs = new CancelRequestEventArgs(_feignClient, cancellationToken);
_feignClient.OnCancelRequest(cancelArgs);
#endregion
return(await base.SendAsync(request, cancellationToken));
}
catch (Exception e)
{
if (!e.IsSkipLog())
{
_logger?.LogError(e, "Exception during SendAsync()");
}
if (e is HttpRequestException)
{
FeignHttpRequestException feignHttpRequestException = new FeignHttpRequestException(_feignClient, feignRequest, (HttpRequestException)e);
ExceptionDispatchInfo exceptionDispatchInfo = ExceptionDispatchInfo.Capture(feignHttpRequestException);
exceptionDispatchInfo.Throw();
}
throw;
}
finally
{
request.RequestUri = current;
}
}
internal SendingRequestEventArgs(IFeignClient feignClient, FeignHttpRequestMessage requestMessage) : base(feignClient)
{
RequestMessage = requestMessage;
}
