private void HandleResponseError <TResponse>(Exception exception, RequestState <TResponse> requestState)
{
var webEx = exception as WebException;
if (webEx != null
#if !SILVERLIGHT
&& webEx.Status == WebExceptionStatus.ProtocolError
#endif
)
{
var errorResponse = ((HttpWebResponse)webEx.Response);
Log.Error(webEx);
Log.DebugFormat("Status Code : {0}", errorResponse.StatusCode);
Log.DebugFormat("Status Description : {0}", errorResponse.StatusDescription);
var serviceEx = new WebServiceException(errorResponse.StatusDescription)
{
StatusCode = (int)errorResponse.StatusCode,
};
try
{
using (var stream = errorResponse.GetResponseStream())
{
//Uncomment to Debug exceptions:
//var strResponse = new StreamReader(stream).ReadToEnd();
//Console.WriteLine("Response: " + strResponse);
//stream.Position = 0;
serviceEx.ResponseBody = errorResponse.GetResponseStream().ReadFully().FromUtf8Bytes();
#if !MONOTOUCH
// MonoTouch throws NotSupportedException when setting System.Net.WebConnectionStream.Position
// Not sure if the stream is used later though, so may have to copy to MemoryStream and
// pass that around instead after this point?
stream.Position = 0;
#endif
serviceEx.ResponseDto = this.StreamDeserializer(typeof(TResponse), stream);
requestState.HandleError((TResponse)serviceEx.ResponseDto, serviceEx);
}
}
catch (Exception innerEx)
{
// Oh, well, we tried
Log.Debug(string.Format("WebException Reading Response Error: {0}", innerEx.Message), innerEx);
requestState.HandleError(default(TResponse), new WebServiceException(errorResponse.StatusDescription, innerEx)
{
StatusCode = (int)errorResponse.StatusCode,
});
}
return;
}
var authEx = exception as AuthenticationException;
if (authEx != null)
{
var customEx = WebRequestUtils.CreateCustomException(requestState.Url, authEx);
Log.Debug(string.Format("AuthenticationException: {0}", customEx.Message), customEx);
requestState.HandleError(default(TResponse), authEx);
}
Log.Debug(string.Format("Exception Reading Response Error: {0}", exception.Message), exception);
requestState.HandleError(default(TResponse), exception);
_webRequest = null;
}
private void ResponseCallback <T>(IAsyncResult asyncResult)
#endif
{
var requestState = (RequestState <T>)asyncResult.AsyncState;
try
{
var webRequest = requestState.WebRequest;
requestState.WebResponse = (HttpWebResponse)webRequest.EndGetResponse(asyncResult);
ApplyWebResponseFilters(requestState.WebResponse);
if (typeof(T) == typeof(HttpWebResponse))
{
requestState.HandleSuccess((T)(object)requestState.WebResponse);
return;
}
// Read the response into a Stream object.
var responseStream = requestState.WebResponse.GetResponseStream();
requestState.ResponseStream = responseStream;
#if NETFX_CORE
var task = responseStream.ReadAsync(requestState.BufferRead, 0, BufferSize);
ReadCallBack <T>(task, requestState);
#else
responseStream.BeginRead(requestState.BufferRead, 0, BufferSize, ReadCallBack <T>, requestState);
#endif
return;
}
catch (Exception ex)
{
var firstCall = Interlocked.Increment(ref requestState.RequestCount) == 1;
if (firstCall && WebRequestUtils.ShouldAuthenticate(ex, this.UserName, this.Password))
{
try
{
requestState.WebRequest = (HttpWebRequest)WebRequest.Create(requestState.Url);
if (StoreCookies)
{
requestState.WebRequest.CookieContainer = CookieContainer;
}
requestState.WebRequest.AddBasicAuth(this.UserName, this.Password);
if (OnAuthenticationRequired != null)
{
OnAuthenticationRequired(requestState.WebRequest);
}
SendWebRequestAsync(
requestState.HttpMethod, requestState.Request,
requestState, requestState.WebRequest);
}
catch (Exception /*subEx*/)
{
HandleResponseError(ex, requestState);
}
return;
}
HandleResponseError(ex, requestState);
}
}
