Esempio n. 1
0
        private void HandleResponseError <TResponse>(Exception exception, AsyncState <TResponse> state)
        {
            var webEx = exception as WebException;

            if (webEx.IsWebException())
            {
                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 = stream.ReadFully().FromUtf8Bytes();

                        stream.ResetStream();

                        serviceEx.ResponseDto = this.StreamDeserializer(typeof(TResponse), stream);
                        state.HandleError((TResponse)serviceEx.ResponseDto, serviceEx);
                    }
                }
                catch (Exception innerEx)
                {
                    // Oh, well, we tried
                    Log.Debug(string.Format("WebException Reading Response Error: {0}", innerEx.Message), innerEx);
                    state.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(state.Url, authEx);

                Log.Debug(string.Format("AuthenticationException: {0}", customEx.Message), customEx);
                state.HandleError(default(TResponse), authEx);
            }

            Log.Debug(string.Format("Exception Reading Response Error: {0}", exception.Message), exception);
            state.HandleError(default(TResponse), exception);

            CancelAsyncFn = null;
        }
Esempio n. 2
0
        internal static ITimer CreateTimer <TResponse>(this AsyncState <TResponse> state, TimeSpan timeOut)
        {
#if NETFX_CORE
            return(new NetFxAsyncTimer(ThreadPoolTimer.CreateTimer(request.TimedOut, timeOut)));
#else
            return(new AsyncTimer(new Timer(state.TimedOut, state, (int)timeOut.TotalMilliseconds, Timeout.Infinite)));
#endif
        }
Esempio n. 3
0
        private void SendWebRequestAsync <TResponse>(string httpMethod, object request,
                                                     AsyncState <TResponse> state, HttpWebRequest client)
        {
            client.Accept = ContentType;

            if (this.EmulateHttpViaPost)
            {
                client.Method = "POST";
                client.Headers[HttpHeaders.XHttpMethodOverride] = httpMethod;
            }
            else
            {
                client.Method = httpMethod;
            }

            PclExportClient.Instance.AddHeader(client, Headers);

            //EmulateHttpViaPost is also forced for SL5 clients sending non GET/POST requests
            PclExport.Instance.Config(client, userAgent: UserAgent);

            if (this.authInfo != null && !string.IsNullOrEmpty(this.UserName))
            {
                client.AddAuthInfo(this.UserName, this.Password, authInfo);
            }
            else if (this.BearerToken != null)
            {
                client.Headers[HttpHeaders.Authorization] = "Bearer " + this.BearerToken;
            }
            else if (this.Credentials != null)
            {
                client.Credentials = this.Credentials;
            }
            else if (this.AlwaysSendBasicAuthHeader)
            {
                client.AddBasicAuth(this.UserName, this.Password);
            }

            ApplyWebRequestFilters(client);

            try
            {
                if (client.Method.HasRequestBody())
                {
                    client.ContentType = ContentType;
                    client.BeginGetRequestStream(RequestCallback <TResponse>, state);
                }
                else
                {
                    state.WebRequest.BeginGetResponse(ResponseCallback <TResponse>, state);
                }
            }
            catch (Exception ex)
            {
                // BeginGetRequestStream can throw if request was aborted
                HandleResponseError(ex, state);
            }
        }
        private void SendWebRequestAsync <TResponse>(string httpMethod, object request,
                                                     AsyncState <TResponse> state, HttpWebRequest webRequest)
        {
            var httpGetOrDeleteOrHead = (httpMethod == "GET" || httpMethod == "DELETE" || httpMethod == "HEAD");

            webRequest.Accept = string.Format("{0}, */*", ContentType);

            //Methods others than GET and POST are only supported by Client request creator, see
            //http://msdn.microsoft.com/en-us/library/cc838250(v=vs.95).aspx
            if (this.EmulateHttpViaPost && httpMethod != "GET" && httpMethod != "POST")
            {
                webRequest.Method = "POST";
                webRequest.Headers[HttpHeaders.XHttpMethodOverride] = httpMethod;
            }
            else
            {
                webRequest.Method = httpMethod;
            }

            PclExportClient.Instance.AddHeader(webRequest, Headers);

            PclExport.Instance.Config(webRequest, userAgent: UserAgent);

            if (this.Credentials != null)
            {
                webRequest.Credentials = this.Credentials;
            }
            if (this.AlwaysSendBasicAuthHeader)
            {
                webRequest.AddBasicAuth(this.UserName, this.Password);
            }

            ApplyWebRequestFilters(webRequest);

            try
            {
                if (!httpGetOrDeleteOrHead && request != null)
                {
                    webRequest.ContentType = ContentType;
                    webRequest.BeginGetRequestStream(RequestCallback <TResponse>, state);
                }
                else
                {
                    state.WebRequest.BeginGetResponse(ResponseCallback <TResponse>, state);
                }
            }
            catch (Exception ex)
            {
                // BeginGetRequestStream can throw if request was aborted
                HandleResponseError(ex, state);
            }
        }
Esempio n. 5
0
        private void SendWebRequestAsync <TResponse>(string httpMethod, object request,
                                                     AsyncState <TResponse> state, HttpWebRequest webRequest)
        {
            webRequest.Accept = string.Format("{0}, */*", ContentType);

            if (this.EmulateHttpViaPost)
            {
                webRequest.Method = "POST";
                webRequest.Headers[HttpHeaders.XHttpMethodOverride] = httpMethod;
            }
            else
            {
                webRequest.Method = httpMethod;
            }

            PclExportClient.Instance.AddHeader(webRequest, Headers);

            //EmulateHttpViaPost is also forced for SL5 clients sending non GET/POST requests
            PclExport.Instance.Config(webRequest, userAgent: UserAgent);

            if (this.Credentials != null)
            {
                webRequest.Credentials = this.Credentials;
            }
            if (this.AlwaysSendBasicAuthHeader)
            {
                webRequest.AddBasicAuth(this.UserName, this.Password);
            }

            ApplyWebRequestFilters(webRequest);

            try
            {
                if (webRequest.Method.HasRequestBody())
                {
                    webRequest.ContentType = ContentType;
                    webRequest.BeginGetRequestStream(RequestCallback <TResponse>, state);
                }
                else
                {
                    state.WebRequest.BeginGetResponse(ResponseCallback <TResponse>, state);
                }
            }
            catch (Exception ex)
            {
                // BeginGetRequestStream can throw if request was aborted
                HandleResponseError(ex, state);
            }
        }
Esempio n. 6
0
        private void SendWebRequest <TResponse>(string httpMethod, string absoluteUrl, object request, CancellationToken token,
                                                Action <TResponse> onSuccess, Action <object, Exception> onError, Action <WebResponse> onResponseInit = null)
        {
            if (httpMethod == null)
            {
                throw new ArgumentNullException(nameof(httpMethod));
            }

            this.PopulateRequestMetadata(request);

            var requestUri     = absoluteUrl;
            var hasQueryString = request != null && !httpMethod.HasRequestBody();

            if (hasQueryString)
            {
                var queryString = QueryStringSerializer.SerializeToString(request);
                if (!string.IsNullOrEmpty(queryString))
                {
                    requestUri += "?" + queryString;
                }
            }

            var webRequest = this.CreateHttpWebRequest(requestUri);

            var requestState = new AsyncState <TResponse>(BufferSize)
            {
                HttpMethod                = httpMethod,
                Url                       = requestUri,
                WebRequest                = webRequest,
                Request                   = request,
                Token                     = token,
                OnResponseInit            = onResponseInit,
                OnSuccess                 = onSuccess,
                OnError                   = onError,
                UseSynchronizationContext = CaptureSynchronizationContext ? SynchronizationContext.Current : null,
                HandleCallbackOnUIThread  = HandleCallbackOnUiThread,
            };

            if (!DisableTimer)
            {
                requestState.StartTimer(this.Timeout.GetValueOrDefault(DefaultTimeout));
            }

            SendWebRequestAsync(httpMethod, request, requestState, webRequest);
        }
        private void SendWebRequest <TResponse>(string httpMethod, string absoluteUrl, object request,
                                                Action <TResponse> onSuccess, Action <TResponse, Exception> onError)
        {
            if (httpMethod == null)
            {
                throw new ArgumentNullException("httpMethod");
            }

            var requestUri            = absoluteUrl;
            var httpGetOrDeleteOrHead = (httpMethod == "GET" || httpMethod == "DELETE" || httpMethod == "HEAD");
            var hasQueryString        = request != null && httpGetOrDeleteOrHead;

            if (hasQueryString)
            {
                var queryString = QueryStringSerializer.SerializeToString(request);
                if (!string.IsNullOrEmpty(queryString))
                {
                    requestUri += "?" + queryString;
                }
            }

            var webRequest = this.CreateHttpWebRequest(requestUri);

            var requestState = new AsyncState <TResponse>(BufferSize)
            {
                HttpMethod = httpMethod,
                Url        = requestUri,
                WebRequest = webRequest,
                Request    = request,
                OnSuccess  = onSuccess,
                OnError    = onError,
                UseSynchronizationContext = CaptureSynchronizationContext ? SynchronizationContext.Current : null,
                HandleCallbackOnUIThread  = HandleCallbackOnUiThread,
            };

            requestState.StartTimer(this.Timeout.GetValueOrDefault(DefaultTimeout));

            SendWebRequestAsync(httpMethod, request, requestState, webRequest);
        }
 public override ITimer CreateTimer <TResponse>(AsyncState <TResponse> state, TimeSpan timeOut)
 {
     return(new AsyncTimer(new
                           System.Threading.Timer(state.TimedOut, state, (int)timeOut.TotalMilliseconds, Timeout.Infinite)));
 }
        private void HandleResponseError <TResponse>(Exception exception, AsyncState <TResponse> state)
        {
            var webEx = exception as WebException;

            if (PclExportClient.Instance.IsWebException(webEx))
            {
                var errorResponse = (HttpWebResponse)webEx.Response;
                Log.Error(webEx);
                if (Log.IsDebugEnabled)
                {
                    Log.DebugFormat("Status Code : {0}", errorResponse.StatusCode);
                    Log.DebugFormat("Status Description : {0}", errorResponse.StatusDescription);
                }

                var serviceEx = new WebServiceException(errorResponse.StatusDescription)
                {
                    StatusCode        = (int)errorResponse.StatusCode,
                    StatusDescription = errorResponse.StatusDescription,
                    ResponseHeaders   = errorResponse.Headers
                };

                try
                {
                    using (var stream = errorResponse.GetResponseStream())
                    {
                        var bytes = stream.ReadFully();
                        serviceEx.ResponseBody = bytes.FromUtf8Bytes();
                        var errorResponseType = WebRequestUtils.GetErrorResponseDtoType <TResponse>(state.Request);

                        if (stream.CanSeek)
                        {
                            PclExport.Instance.ResetStream(stream);
                            serviceEx.ResponseDto = this.StreamDeserializer(errorResponseType, stream);
                        }
                        else //Android
                        {
                            using (var ms = MemoryStreamFactory.GetStream(bytes))
                            {
                                serviceEx.ResponseDto = this.StreamDeserializer(errorResponseType, ms);
                            }
                        }
                        state.HandleError(serviceEx.ResponseDto, serviceEx);
                    }
                }
                catch (Exception innerEx)
                {
                    // Oh, well, we tried
                    Log.Debug(string.Format("WebException Reading Response Error: {0}", innerEx.Message), innerEx);
                    state.HandleError(default(TResponse), new WebServiceException(errorResponse.StatusDescription, innerEx)
                    {
                        StatusCode        = (int)errorResponse.StatusCode,
                        StatusDescription = errorResponse.StatusDescription,
                        ResponseHeaders   = errorResponse.Headers
                    });
                }
                return;
            }

            var authEx = exception as AuthenticationException;

            if (authEx != null)
            {
                var customEx = WebRequestUtils.CreateCustomException(state.Url, authEx);

                Log.Debug(string.Format("AuthenticationException: {0}", customEx.Message), customEx);
                state.HandleError(default(TResponse), authEx);
            }

            Log.Debug(string.Format("Exception Reading Response Error: {0}", exception.Message), exception);
            state.HandleError(default(TResponse), exception);

            CancelAsyncFn = null;
        }
Esempio n. 10
0
        private void ReadCallBack <T>(Task <int> task, AsyncState <T> requestState)
        {
            task.ContinueWith(t =>
            {
                try
                {
                    var responseStream = requestState.ResponseStream;

                    int read = t.Result;
                    if (read > 0)
                    {
                        requestState.BytesData.Write(requestState.BufferRead, 0, read);

                        var responeStreamTask = responseStream.ReadAsync(requestState.BufferRead, 0, BufferSize);

                        requestState.ResponseBytesRead += read;
                        if (OnDownloadProgress != null)
                        {
                            OnDownloadProgress(requestState.ResponseBytesRead, requestState.ResponseContentLength);
                        }

                        ReadCallBack(responeStreamTask, requestState);
                        return;
                    }

                    Interlocked.Increment(ref requestState.Completed);

                    var response = default(T);
                    try
                    {
                        requestState.BytesData.Position = 0;
                        if (typeof(T) == typeof(Stream))
                        {
                            response = (T)(object)requestState.BytesData;
                        }
                        else
                        {
                            var reader = requestState.BytesData;
                            try
                            {
                                if (typeof(T) == typeof(string))
                                {
                                    using (var sr = new StreamReader(reader))
                                    {
                                        response = (T)(object)sr.ReadToEnd();
                                    }
                                }
                                else if (typeof(T) == typeof(byte[]))
                                {
                                    response = (T)(object)reader.ToArray();
                                }
                                else
                                {
                                    response = (T)this.StreamDeserializer(typeof(T), reader);
                                }
                            }
                            finally
                            {
                                if (reader.CanRead)
                                {
                                    reader.Dispose(); // Not yet disposed, but could've been.
                                }
                            }
                        }

                        PclExportClient.Instance.SynchronizeCookies(this);

                        requestState.HandleSuccess(response);
                    }
                    catch (Exception ex)
                    {
                        Log.Debug(string.Format("Error Reading Response Error: {0}", ex.Message), ex);
                        requestState.HandleError(default(T), ex);
                    }
                    finally
                    {
                        PclExportClient.Instance.CloseReadStream(responseStream);

                        CancelAsyncFn = null;
                    }
                }
                catch (Exception ex)
                {
                    HandleResponseError(ex, requestState);
                }
            });
        }
Esempio n. 11
0
 internal static ITimer CreateTimer <TResponse>(this AsyncState <TResponse> state, TimeSpan timeOut)
 {
     return(PclExportClient.Instance.CreateTimer(state.TimedOut, timeOut, state));
 }
Esempio n. 12
0
 public override ITimer CreateTimer <TResponse>(AsyncState <TResponse> state, TimeSpan timeOut)
 {
     return(new WinStoreAsyncTimer(ThreadPoolTimer.CreateTimer(state.TimedOut, timeOut)));
 }