Example #1
0
        void IPluginHost.HttpRequest(HttpRequest request)
        {
            if (request.Callback == null)
            {
                var url = request.Url;
                Log.Debug("HttpRequest Callback is not set. Using default to log in case of error. " + url);

                request.Callback = (response, state) =>
                    {
                        if (response.Status != HttpRequestQueueResult.Success)
                        {
                            Log.Warn(
                                string.Format(
                                    "Request to '{0}' failed. reason={1}, httpcode={2} webstatus={3}, HttpQueueResult={4}.",
                                    url,
                                    response.Reason,
                                    response.HttpCode,
                                    response.WebStatus,
                                    response.Status));
                        }
                    };
            }

            var stateCarrier = new ResponseDataCarrier();
            try
            {
                var webRequest = (HttpWebRequest)WebRequest.Create(request.Url);
                webRequest.Proxy = null;
                webRequest.Method = request.Method ?? "GET";
                webRequest.ContentType = request.ContentType;
                webRequest.Accept = request.Accept;
                webRequest.Timeout = this.httpQueueRequestTimeout;

                if (request.CustomHeaders != null)
                {
                    foreach (var kv in request.CustomHeaders)
                    {
                        webRequest.Headers.Add(kv.Key, kv.Value);
                    }
                }

                if (request.Headers != null)
                {
                    foreach (var kv in request.Headers)
                    {
                        webRequest.Headers.Add(kv.Key, kv.Value);
                    }
                }

                HttpRequestQueueCallback callback = (result, httpRequest, state) =>
                    {
                        if (Log.IsDebugEnabled)
                        {
                            Log.DebugFormat("callback for request is called.url:{0}.IsAsync:{1}",
                                httpRequest.WebRequest.RequestUri, request.Async);
                        }

                        if (request.Async)
                        {
                            this.ExecutionFiber.Enqueue(() => this.HttpRequestHttpCallback(request, result, httpRequest, state));
                        }
                        else
                        {
                            stateCarrier.HttpRequest = httpRequest;
                            stateCarrier.Result = result;
                            stateCarrier.State = state;

                            this.onHttpResonseEvent.Set();
                        }
                    };

                if (webRequest.Method == "POST")
                {
                    this.httpRequestQueue.Enqueue(webRequest, request.DataStream.ToArray(), callback, request.UserState, request.Async ? 3 : 0);
                }
                else
                {
                    this.httpRequestQueue.Enqueue(webRequest, callback, request.UserState, request.Async ? 3 : 0);
                }
            }
            catch (WebException e)
            {
                Log.Error(string.Format("Exception calling Url:{0}", request.Url), e);
                var response = new HttpResponseImpl(request, null, string.Empty, HttpRequestQueueResultCode.Error, 0, e.Message, (int)e.Status);
                request.Callback(response, request.UserState);
                return;
            }
            catch (Exception ex)
            {
                Log.Error(string.Format("Exception calling Url:{0}", request.Url), ex);
                var response = new HttpResponseImpl(
                    request,
                    null,
                    string.Empty,
                    HttpRequestQueueResultCode.Error,
                    0,
                    ex.Message,
                    (int)WebExceptionStatus.UnknownError);
                request.Callback(response, request.UserState);
                return;
            }

            if (request.Async)
            {
                Log.Debug("HttpRequest() - NOT Waiting for HttpResponse.");
                // we return immediately without waiting for response
                return;
            }

            var timeout = this.httpQueueRequestTimeout + (int) this.httpRequestQueue.QueueTimeout.TotalMilliseconds + 1000;
            // waiting for our callback to release us
            Log.Debug("HttpRequest() - Waiting for HttpResponse.");
            if (!this.onHttpResonseEvent.WaitOne(timeout))
            {
                Log.WarnFormat("Plugin's sync http call timedout. url:{0}, Method:{1}, timeout:{2}", request.Url, request.Method, timeout);
                return;
            }
            Log.Debug("HttpRequest() - Done.");

            this.HttpRequestHttpCallback(request, stateCarrier.Result, stateCarrier.HttpRequest, stateCarrier.State);
        }
Example #2
0
        private void HttpRequestHttpCallback(HttpRequest request, HttpRequestQueueResultCode result, AsyncHttpRequest httpRequest, object state)
        {
            var statusCode = -1;
            string statusDescription;
            byte[] responseData = null;

            try
            {
                switch (result)
                {
                    case HttpRequestQueueResultCode.Success:
                        statusCode = (int)httpRequest.WebResponse.StatusCode;
                        statusDescription = httpRequest.WebResponse.StatusDescription;
                        responseData = httpRequest.Response;
                        break;

                    case HttpRequestQueueResultCode.Error:
                        if (httpRequest.WebResponse != null)
                        {
                            statusCode = (int)httpRequest.WebResponse.StatusCode;
                            statusDescription = httpRequest.WebResponse.StatusDescription;
                        }
                        else
                        {
                            statusDescription = httpRequest.Exception.Message;
                        }

                        break;
                    default:
                        statusCode = -1;
                        statusDescription = string.Empty;
                        break;
                }
            }
            catch (Exception ex)
            {
                // we should never get her
                statusDescription = ex.Message;
            }

            var response = new HttpResponseImpl(
                request,
                responseData,
                responseData == null ? null : Encoding.UTF8.GetString(responseData, 0, responseData.Length),
                result,
                statusCode,
                statusDescription,
                httpRequest == null ? -1 : (int)httpRequest.WebStatus);

            Log.Debug("Got HttpResoonse - executing callback.");

            // Sync request triggers an event to release the waiting Request thread to continue
            try
            {
                request.Callback(response, state);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                if (request.Async)
                {
                    this.Plugin.ReportError(ErrorCodes.AsyncCallbackException, ex, state);
                }
                else
                {
                    throw;
                }
            }
        }