public void DescriptorIsFromConstructor()
{
var descriptor = new FunctionDescriptor();
var eventArgs = new ReceivingResponseEventArgs(new ResponseMessageSimulator(null), descriptor);
eventArgs.Descriptor.Should().BeSameAs(descriptor);
}
private ReceivingResponseEventArgs <TService, TResult> InvokeReceivingResponseEvent <TResult>(FeignClientHttpRequest request, HttpResponseMessage responseMessage)
{
ReceivingResponseEventArgs <TService, TResult> receivingResponseEventArgs = new ReceivingResponseEventArgs <TService, TResult>(this, request, responseMessage);
OnReceivingResponse(receivingResponseEventArgs);
return(receivingResponseEventArgs);
}
void Container_ReceivingResponse(object sender, ReceivingResponseEventArgs e)
{
if (e.ResponseMessage.StatusCode == (int)System.Net.HttpStatusCode.InternalServerError)
{
using (StreamReader reader = new StreamReader(e.ResponseMessage.GetStream()))
{
string contents = reader.ReadToEnd();
var ex = new DataServiceClientException(contents);
if (this.Format.ODataFormat == ODataFormat.Atom)
{
DataServiceExceptionAtomParser.Throw(ex);
}
else if (this.Format.ODataFormat == ODataFormat.Json)
{
DataServiceExceptionJsonParser.Throw(ex);
}
else
{
throw ex;
}
}
}
else if (e.ResponseMessage.StatusCode == (int)System.Net.HttpStatusCode.Unauthorized)
{
var h = e.ResponseMessage.Headers.Where(kvp => kvp.Key == "WWW-Authenticate").Select(kvp => kvp.Value).FirstOrDefault();
}
}
public void IsBatchOperationIsSetInConstructor()
{
var eventArgs = new ReceivingResponseEventArgs(new ResponseMessageSimulator(null), null, true);
eventArgs.IsBatchPart.Should().BeTrue();
eventArgs = new ReceivingResponseEventArgs(new ResponseMessageSimulator(null), null, false);
eventArgs.IsBatchPart.Should().BeFalse();
}
public void ConstructorShouldGetHeadersFromParameter()
{
var originalHeaders = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("first-header", "first_value"), new KeyValuePair <string, string>("second header", "second value")
};
var eventArgs = new ReceivingResponseEventArgs(new ResponseMessageSimulator(originalHeaders), null, false);
eventArgs.ResponseMessage.Headers.Count().Should().Be(originalHeaders.Count);
originalHeaders.ForEach((h) => eventArgs.ResponseMessage.Headers.Should().Contain(h));
}
/// <summary>
/// 获取响应结果
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="request"></param>
/// <param name="responseMessage"></param>
/// <returns></returns>
private Task <TResult> GetResultAsync <TResult>(FeignClientHttpRequest request, HttpResponseMessage responseMessage)
{
if (responseMessage == null)
{
return(Task.FromResult(default(TResult)));
}
#region ReceivingResponse
ReceivingResponseEventArgs <TService, TResult> receivingResponseEventArgs = InvokeReceivingResponseEvent <TResult>(request, responseMessage);
//if (receivingResponseEventArgs.Result != null)
if (receivingResponseEventArgs._isSetResult)
{
return(Task.FromResult(receivingResponseEventArgs.GetResult()));
}
#endregion
return(GetResultInternalAsync <TResult>(request, responseMessage));
}
private void ContextReceivingResponse(object sender, ReceivingResponseEventArgs e)
{
Logger.Debug($"Recieving response: {JsonConvert.SerializeObject(e.ResponseMessage, Formatting.Indented)}");
if (!(e.ResponseMessage is HttpWebResponseMessage responseMessage))
{
throw new UserFriendlyException($"Request Failed: {e.ResponseMessage.StatusCode}");
}
if (!(responseMessage.Response is HttpWebResponse response))
{
throw new UserFriendlyException($"Request Failed: {responseMessage.Response.StatusCode} {responseMessage.Response.StatusDescription}");
}
if (response.StatusCode == HttpStatusCode.GatewayTimeout)
{
using (var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
Logger.Debug($"Content: {reader.ReadToEnd()}");
throw new UserFriendlyException((int)response.StatusCode, "Web server received an invalid response while acting as a gateway or proxy server.");
}
}
if (response.StatusCode == HttpStatusCode.BadRequest ||
response.StatusCode == HttpStatusCode.InternalServerError ||
response.StatusCode == HttpStatusCode.Unauthorized)
{
using (var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
Logger.Debug($"Content: {reader.ReadToEnd()}");
if (JsonValidationHelper.IsValidJson(reader.ReadToEnd()))
{
var error = JsonConvert.DeserializeObject <ODataErrorResponse>(reader.ReadToEnd());
Logger.Error($"{response.StatusCode} ({(int) response.StatusCode}) - {error.Message}");
throw new UserFriendlyException((int)response.StatusCode, error.Message);
}
throw new UserFriendlyException((int)response.StatusCode, reader.ReadToEnd());
}
}
}
async Task <TResult> GetResultAsync <TResult>(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)
{
return((TResult)receivingResponseEventArgs.Result);
}
#endregion
EnsureSuccess(responseMessage);
return(Newtonsoft.Json.JsonConvert.DeserializeObject <TResult>(await responseMessage.Content.ReadAsStringAsync()));
}
void Container_ReceivingResponse(object sender, ReceivingResponseEventArgs e)
{
if (e.ResponseMessage.StatusCode == (int)System.Net.HttpStatusCode.InternalServerError)
{
using (StreamReader reader = new StreamReader(e.ResponseMessage.GetStream()))
{
string contents = reader.ReadToEnd();
var ex = new DataServiceClientException(contents);
if (this.Format.ODataFormat == ODataFormat.Atom)
DataServiceExceptionAtomParser.Throw(ex);
else if (this.Format.ODataFormat == ODataFormat.Json)
DataServiceExceptionJsonParser.Throw(ex);
else
throw ex;
}
}
else if (e.ResponseMessage.StatusCode == (int)System.Net.HttpStatusCode.Unauthorized)
{
var h = e.ResponseMessage.Headers.Where(kvp => kvp.Key == "WWW-Authenticate").Select(kvp => kvp.Value).FirstOrDefault();
}
}
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)));
}
private void ServiceContainer_ReceivingResponse(object sender, ReceivingResponseEventArgs e)
{
if (null == e.ResponseMessage)
{
return;
}
//InspectResponseStream(e.ResponseMessage.GetStream());
string strMessage = e.ResponseMessage.GetHeader("Set-Cookie");
//Format of the Set-Cookie content in response of login action
//B1SESSION=146eae44-fc3a-11e3-8000-047d7ba5aff2;HttpOnly;,ROUTEID=.node2; path=/b1s
//Format of the cookie to be sent in request
//Cookie: B1SESSION=57a86a60-fc3a-11e3-8000-047d7ba5aff2; ROUTEID=.node1
if (strMessage != null && strMessage.Length > 0)
{
//The ROUTEID information will be returned during login, if sever is configured to be "Clustered" Mode.
int idx = strMessage.IndexOf("ROUTEID=");
if (idx > 0)
{
string strSubString = strMessage.Substring(idx);
int idxSplitter = strSubString.IndexOf(";");
if (idxSplitter > 0)
{
routeIdString = strSubString.Substring(0, idxSplitter);
}
else
{
routeIdString = string.Empty;
}
}
}
}
/// <summary>
/// Loads the metadata and converts it into an EdmModel that is then used by a dataservice context
/// This allows the user to use the DataServiceContext directly without having to manually pass an IEdmModel in the Format
/// </summary>
/// <returns>A service model to be used in format tracking</returns>
internal IEdmModel LoadServiceModelFromNetwork()
{
DataServiceClientRequestMessage httpRequest;
BuildingRequestEventArgs requestEventArgs = null;
// test hook for injecting a network request to use instead of the default
if (InjectMetadataHttpNetworkRequest != null)
{
httpRequest = InjectMetadataHttpNetworkRequest();
}
else
{
requestEventArgs = new BuildingRequestEventArgs(
"GET",
context.GetMetadataUri(),
null,
null,
context.HttpStack);
// fire the right events if they exist to allow user to modify the request
if (context.HasBuildingRequestEventHandlers)
{
requestEventArgs = context.CreateRequestArgsAndFireBuildingRequest(
requestEventArgs.Method,
requestEventArgs.RequestUri,
requestEventArgs.HeaderCollection,
requestEventArgs.ClientHttpStack,
requestEventArgs.Descriptor);
}
DataServiceClientRequestMessageArgs args = new DataServiceClientRequestMessageArgs(
requestEventArgs.Method,
requestEventArgs.RequestUri,
context.UseDefaultCredentials,
context.UsePostTunneling,
requestEventArgs.Headers);
httpRequest = new HttpClientRequestMessage(args);
}
Descriptor descriptor = requestEventArgs != null ? requestEventArgs.Descriptor : null;
// fire the right events if they exist
if (context.HasSendingRequest2EventHandlers)
{
SendingRequest2EventArgs eventArgs = new SendingRequest2EventArgs(
httpRequest,
descriptor,
false);
context.FireSendingRequest2(eventArgs);
}
Task <IODataResponseMessage> asyncResponse =
Task <IODataResponseMessage> .Factory.FromAsync(httpRequest.BeginGetResponse, httpRequest.EndGetResponse,
httpRequest);
IODataResponseMessage response = asyncResponse.GetAwaiter().GetResult();
ReceivingResponseEventArgs responseEvent = new ReceivingResponseEventArgs(response, descriptor);
context.FireReceivingResponseEvent(responseEvent);
using (StreamReader streamReader = new StreamReader(response.GetStream()))
using (XmlReader xmlReader = XmlReader.Create(streamReader))
{
return(CsdlReader.Parse(xmlReader));
}
}
private void RequestLogger(object eventSender, ReceivingResponseEventArgs eventArgs)
{
eventArgs.ResponseMessage.ToString();
}
protected internal virtual void OnReceivingResponse(ReceivingResponseEventArgs <TService> e)
{
_serviceFeignClientPipeline?.OnReceivingResponse(this, e);
_serviceIdFeignClientPipeline?.OnReceivingResponse(this, e);
_globalFeignClientPipeline?.OnReceivingResponse(this, e);
}
protected internal override void OnReceivingResponse(ReceivingResponseEventArgs e)
{
_serviceTypeFeignClientPipeline?.OnReceivingResponse(this, e);
base.OnReceivingResponse(e);
}
private void RequestLogger(object eventSender, ReceivingResponseEventArgs eventArgs)
{
// TODO : Implement logging feature
// eventArgs.ResponseMessage.ToString();
}
