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