Exemple #1
0
        public static AsyncHttpRequest GetAsync(this HttpWebRequest webRequest, Action <AsyncHttpRequest> callBack)
        {
            var asyncRequest = new AsyncHttpRequest(webRequest, callBack);

            asyncRequest.GetAsync();
            return(asyncRequest);
        }
Exemple #2
0
        private void ProcessWebResponse(AsyncHttpRequest request)
        {
            this.RunningRequestsCount--;

            switch (this.QueueState)
            {
            case HttpRequestQueueState.Connecting:
                this.ProcessResponseConnecting(request);
                break;

            case HttpRequestQueueState.Running:
                this.ProcessResponseRunning(request);
                break;

            case HttpRequestQueueState.Reconnecting:
                this.ProcessResponseReConnecting(request);
                break;

            case HttpRequestQueueState.Offline:
                this.ProcessResponseOffline(request);
                break;
            }

            this.ProcessQueuedItems();
        }
Exemple #3
0
 private void ExecuteHttpRequest(QueuedRequest request)
 {
     try
     {
         this.RunningRequestsCount++;
         var asyncHttpRequest = new AsyncHttpRequest(request.Request, this.WebRequestCallback, request);
         if (request.PostData == null)
         {
             asyncHttpRequest.GetAsync();
         }
         else
         {
             asyncHttpRequest.PostAsync(request.PostData);
         }
     }
     catch (Exception ex)
     {
         log.Error(ex);
     }
 }
Exemple #4
0
        private void ProcessResponseRunning(AsyncHttpRequest request)
        {
            var queuedRequest = (QueuedRequest)request.State;

            switch (request.WebStatus)
            {
            case WebExceptionStatus.Success:
                DecrementTimedOutCount();
                queuedRequest.Callback(HttpRequestQueueResultCode.Success, request, queuedRequest.State);
                break;

            case WebExceptionStatus.Timeout:
                IncrementTimedOutCount();
                queuedRequest.Callback(HttpRequestQueueResultCode.RequestTimeout, request, queuedRequest.State);
                break;

            default:
                this.SetOffline();
                queuedRequest.Callback(HttpRequestQueueResultCode.Error, request, queuedRequest.State);
                break;
            }
        }
 public static AsyncHttpRequest GetAsync(this HttpWebRequest webRequest, Action<AsyncHttpRequest> callBack)
 {
     var asyncRequest = new AsyncHttpRequest(webRequest, callBack);
     asyncRequest.GetAsync();
     return asyncRequest;
 }
        private void ResponseCallBack(HttpRequestQueueResultCode result, AsyncHttpRequest response, object state)
        {
            Interlocked.Increment(ref this.responseCount);

            var requestState = state as RequestState;
            if (requestState != null)
            {
                requestState.Result = result;
                requestState.Response = response;
                requestState.State = state;
                requestState.ResetEvent.Set();
            }

            this.resetEvent.Set();
        }
 private void ResponseCallBack(AsyncHttpRequest request)
 {
     this.resetEvent.Set();
 }
Exemple #8
0
        private void ProcessResponseOffline(AsyncHttpRequest request)
        {
            var queuedRequest = (QueuedRequest)request.State;

            queuedRequest.Callback(HttpRequestQueueResultCode.Offline, null, queuedRequest.State);
        }
Exemple #9
0
 private void WebRequestCallback(AsyncHttpRequest request)
 {
     this.fiber.Enqueue(() => this.ProcessWebResponse(request));
 }
 private void ProcessResponseOffline(AsyncHttpRequest request)
 {
     var queuedRequest = (QueuedRequest)request.State;
     queuedRequest.Callback(HttpRequestQueueResultCode.Offline, null, queuedRequest.State);
 }
        private void ProcessResponseRunning(AsyncHttpRequest request)
        {
            var queuedRequest = (QueuedRequest)request.State;

            switch (request.WebStatus)
            {
                case WebExceptionStatus.Success:
                    DecrementTimedOutCount();
                    queuedRequest.Callback(HttpRequestQueueResultCode.Success, request, queuedRequest.State);
                    break;

                case WebExceptionStatus.Timeout:
                    IncrementTimedOutCount();
                    queuedRequest.Callback(HttpRequestQueueResultCode.RequestTimeout, request, queuedRequest.State);
                    break;

                default:
                    this.SetOffline();
                    queuedRequest.Callback(HttpRequestQueueResultCode.Error, request, queuedRequest.State);
                    break;
            }
        }
        private void ProcessWebResponse(AsyncHttpRequest request)
        {
            this.RunningRequestsCount--;

            switch (this.QueueState)
            {
                case HttpRequestQueueState.Connecting:
                    this.ProcessResponseConnecting(request);
                    break;

                case HttpRequestQueueState.Running:
                    this.ProcessResponseRunning(request);
                    break;

                case HttpRequestQueueState.Reconnecting:
                    this.ProcessResponseReConnecting(request);
                    break;

                case HttpRequestQueueState.Offline:
                    this.ProcessResponseOffline(request);
                    break;
            }

            this.ProcessQueuedItems();           
        }
 private void WebRequestCallback(AsyncHttpRequest request)
 {
     this.fiber.Enqueue(() => this.ProcessWebResponse(request));
 }
 private void ExecuteHttpRequest(QueuedRequest request)
 {
     try
     {
         this.RunningRequestsCount++;
         var asyncHttpRequest = new AsyncHttpRequest(request.Request, this.WebRequestCallback, request);
         if (request.PostData == null)
         {
             asyncHttpRequest.GetAsync();
         }
         else
         {
             asyncHttpRequest.PostAsync(request.PostData);
         }
     }
     catch (Exception ex)
     {
         log.Error(ex);
     }
 }